diff --git a/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/README.md b/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/README.md new file mode 100644 index 0000000..940e3c7 --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/README.md @@ -0,0 +1,46 @@ +# DSV4 DSpark H20 SGLang TP×DP Matrix Benchmark + +NVIDIA H20 + SGLang (Docker) + `DeepSeek-V4-Flash-DSpark` TP×DP matrix benchmark. + +Adapted from `experiments/h20/dsv4_h20_sglang_tp_dp_matrix`, with the model +swapped to `/data1/hf_models/DeepSeek-V4-Flash-DSpark`. All other parameters +(context length 1M, max-running-requests 128, mem-fraction-static 0.88, +moe-runner-backend marlin, ISL/OSL matrix, concurrency rules) are identical to +the non-DSpark H20 SGLang matrix experiment. + +Note: DSpark speculative decoding is a vLLM-only feature in this repository; +SGLang serves the DSpark checkpoint as a standard model. + +## Quick Start + +```bash +# Dry run: print server args and scenario plan only +DRY_RUN=1 bash experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/run_bench.sh + +# Full TP×DP matrix run +bash experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/run_bench.sh + +# Adaptive concurrency search (+16 per step, aligned with +# dsv4_h20_sglang_tp_dp_matrix/run_adaptive_concurrency_add16.sh) +bash experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/run_adaptive_concurrency_add16.sh +``` + +Results land in `experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/results//`. + +## Configuration + +Edit `config.env` or override via environment variables: + +```bash +MODEL_PATH=/data1/hf_models/DeepSeek-V4-Flash-DSpark \ +SGLANG_PORT=30033 \ +bash experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/run_bench.sh +``` + +## Files + +Same layout as `dsv4_h20_sglang_tp_dp_matrix`; see that experiment for details. + +## Platform + +This experiment targets `platforms/nvidia_h20.env`. diff --git a/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/adaptive_config.env b/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/adaptive_config.env new file mode 100644 index 0000000..e35c41f --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/adaptive_config.env @@ -0,0 +1,55 @@ +# Adaptive concurrency search settings. +# +# For each fixed (TP, DP, ISL, OSL), probe: +# C = start, start * multiplier, ... up to max +# and stop after Total TPS has less than TPS_MIN_GAIN_PCT meaningful growth for +# PLATEAU_PATIENCE consecutive points. + +SEARCH_START_CONCURRENCY="${SEARCH_START_CONCURRENCY:-1}" +SEARCH_MAX_CONCURRENCY="${SEARCH_MAX_CONCURRENCY:-512}" +SEARCH_MULTIPLIER="${SEARCH_MULTIPLIER:-2}" +NUM_PROMPTS_MULTIPLIER="${NUM_PROMPTS_MULTIPLIER:-5}" + +# A gain below 2% is treated as throughput saturation. Two consecutive +# low-gain points prevent one noisy measurement from stopping the search. +TPS_MIN_GAIN_PCT="${TPS_MIN_GAIN_PCT:-2.0}" +PLATEAU_PATIENCE="${PLATEAU_PATIENCE:-2}" + +# TTFT SLO early-stop settings. +# When ttft_p95_ms exceeds TTFT_SLO_MS, stop searching the current (ISL, OSL) +# shape and move on to the next scenario. +TTFT_SLO_MS="${TTFT_SLO_MS:-4000}" +ENABLE_TTFT_SLO_STOP="${ENABLE_TTFT_SLO_STOP:-1}" + +# Keep the same random workload semantics as the fixed matrix baseline. +# DATASET_PATH must contain at least SEARCH_MAX_CONCURRENCY times +# NUM_PROMPTS_MULTIPLIER valid two-turn conversations. Set this explicitly to +# random-ids to use generated token IDs without a ShareGPT seed dataset. +BENCH_DATASET_NAME="${BENCH_DATASET_NAME:-random}" +# SGLang interprets 0.0 as Uniform[1, requested_len]. Use 1.0 for fixed +# ISL/OSL points; lower values intentionally benchmark a length distribution. +RANDOM_RANGE_RATIO="${RANDOM_RANGE_RATIO:-1.0}" +# Before each measured point, warm up with the same concurrency so lazy kernel +# compilation and CUDA graph capture are excluded from TTFT/TPS. 0 means no +# cap; set a positive cap only when very high-concurrency warmup is impractical. +BENCH_WARMUP_MAX_REQUESTS="${BENCH_WARMUP_MAX_REQUESTS:-0}" + +# Reject a point if the completed request count or actual token lengths do not +# match the requested workload. +INPUT_LENGTH_TOLERANCE_PCT="${INPUT_LENGTH_TOLERANCE_PCT:-5.0}" +OUTPUT_LENGTH_TOLERANCE_PCT="${OUTPUT_LENGTH_TOLERANCE_PCT:-10.0}" + +MAX_POINT_RETRIES="${MAX_POINT_RETRIES:-1}" +SERVER_RESTART_COOLDOWN_S="${SERVER_RESTART_COOLDOWN_S:-10}" +SCENARIO_TIMEOUT_S="${SCENARIO_TIMEOUT_S:-1800}" +GPU_MEM_SAMPLE_INTERVAL_S="${GPU_MEM_SAMPLE_INTERVAL_S:-1}" + +# Optional space-separated filters, useful for smoke tests: +# TP_LIST="8" ISL_LIST="1024" OSL_LIST="128" +TP_LIST="${TP_LIST:-}" +ISL_LIST="${ISL_LIST:-}" +OSL_LIST="${OSL_LIST:-}" + +DRY_RUN="${DRY_RUN:-0}" +# Counts ISL/OSL shapes per TP/DP config, not individual concurrency probes. +GRID_LIMIT="${GRID_LIMIT:-0}" diff --git a/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260719-033420/adaptive_points.jsonl b/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260719-033420/adaptive_points.jsonl new file mode 100644 index 0000000..25175fa --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260719-033420/adaptive_points.jsonl @@ -0,0 +1,10 @@ +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":14.492392581014428,"request_tps":5.52013751716904,"input_tps":5652.620817581097,"output_tps":706.5776021976371,"total_tps":6359.198419778734,"mean_input_tokens":1024.0,"mean_output_tokens":128.0,"ttft_p50_ms":275.1955550047569,"ttft_p95_ms":1199.5809365849705,"ttft_p99_ms":1567.7653584134532,"tpot_p50_ms":17.705765929106096,"tpot_p95_ms":24.285406901525867,"tpot_p99_ms":26.39990235470311,"e2e_p50_ms":2566.8623489909805,"e2e_p95_ms":4116.441348468652,"e2e_p99_ms":4184.975140201277,"itl_p50_ms":12.21609249478206,"itl_p95_ms":18.241657296311978,"itl_p99_ms":203.41239779605522,"validation_errors":[],"timestamp":"2026-07-19T03:52:17+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":128,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260719-033420/tp2_dp4/raw_outputs/sglang_adaptive_c16_i1024_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260719-033420/tp2_dp4/logs/sglang_c16_i1024_o128_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":16.541128949960694,"request_tps":9.672858514314418,"input_tps":9905.007118657964,"output_tps":1238.1258898322455,"total_tps":11143.13300849021,"mean_input_tokens":1024.0,"mean_output_tokens":128.0,"ttft_p50_ms":647.9971364606172,"ttft_p95_ms":1089.062509179348,"ttft_p99_ms":1175.6126254744595,"tpot_p50_ms":16.88888556288196,"tpot_p95_ms":28.532104768013895,"tpot_p99_ms":35.3447834279445,"e2e_p50_ms":3060.9351039747708,"e2e_p95_ms":4610.618892218916,"e2e_p99_ms":5630.646708928979,"itl_p50_ms":15.499004977755249,"itl_p95_ms":16.721839731326327,"itl_p99_ms":188.37725187302567,"validation_errors":[],"timestamp":"2026-07-19T03:53:17+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":128,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":75.228579,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260719-033420/tp2_dp4/raw_outputs/sglang_adaptive_c32_i1024_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260719-033420/tp2_dp4/logs/sglang_c32_i1024_o128_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":21.233130477019586,"request_tps":11.303090717581645,"input_tps":11574.364894803604,"output_tps":1446.7956118504505,"total_tps":13021.160506654054,"mean_input_tokens":1024.0,"mean_output_tokens":128.0,"ttft_p50_ms":486.864804988727,"ttft_p95_ms":952.6137339096748,"ttft_p99_ms":1005.0622375000966,"tpot_p50_ms":26.016029063153894,"tpot_p95_ms":40.15941050952741,"tpot_p99_ms":53.00041259964926,"e2e_p50_ms":3892.319115519058,"e2e_p95_ms":5580.859578662785,"e2e_p99_ms":7156.2004177534245,"itl_p50_ms":18.462787993485108,"itl_p95_ms":58.77471163112203,"itl_p99_ms":228.41005420195864,"validation_errors":[],"timestamp":"2026-07-19T03:54:22+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":128,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":16.853676,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260719-033420/tp2_dp4/raw_outputs/sglang_adaptive_c48_i1024_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260719-033420/tp2_dp4/logs/sglang_c48_i1024_o128_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":25.50919393496588,"request_tps":12.544496733837232,"input_tps":12845.564655449325,"output_tps":1605.6955819311656,"total_tps":14451.260237380491,"mean_input_tokens":1024.0,"mean_output_tokens":128.0,"ttft_p50_ms":521.4241829817183,"ttft_p95_ms":1405.1232730358606,"ttft_p99_ms":1430.124520753161,"tpot_p50_ms":33.63103892513932,"tpot_p95_ms":48.5871599880588,"tpot_p99_ms":50.86434683662575,"e2e_p50_ms":4981.9329815218225,"e2e_p95_ms":6531.686637896928,"e2e_p99_ms":6904.803581087036,"itl_p50_ms":21.26377448439598,"itl_p95_ms":118.76965116243659,"itl_p99_ms":300.14457790530287,"validation_errors":[],"timestamp":"2026-07-19T03:55:31+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":128,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":10.98289,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260719-033420/tp2_dp4/raw_outputs/sglang_adaptive_c64_i1024_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260719-033420/tp2_dp4/logs/sglang_c64_i1024_o128_a1.log"} +{"status":"COMPLETED","completed":400,"failed":0,"duration_s":29.307607449998613,"request_tps":13.648333480733138,"input_tps":13975.893484270733,"output_tps":1746.9866855338416,"total_tps":15722.880169804574,"mean_input_tokens":1024.0,"mean_output_tokens":128.0,"ttft_p50_ms":640.9560570027679,"ttft_p95_ms":1200.5588721745878,"ttft_p99_ms":1235.7268300198482,"tpot_p50_ms":40.63021040573812,"tpot_p95_ms":57.019023213528214,"tpot_p99_ms":62.24215681025277,"e2e_p50_ms":5830.218538001645,"e2e_p95_ms":7749.885868167618,"e2e_p99_ms":8199.2872930679,"itl_p50_ms":24.971859500510618,"itl_p95_ms":125.9805295063415,"itl_p99_ms":417.22052934754186,"validation_errors":[],"timestamp":"2026-07-19T03:56:44+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":128,"concurrency":80,"num_prompts":400,"warmup_requests":80,"attempt":1,"gain_pct":8.799371,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260719-033420/tp2_dp4/raw_outputs/sglang_adaptive_c80_i1024_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260719-033420/tp2_dp4/logs/sglang_c80_i1024_o128_a1.log"} +{"status":"COMPLETED","completed":480,"failed":0,"duration_s":26.53753042401513,"request_tps":18.087591133409465,"input_tps":18521.69332061129,"output_tps":2315.2116650764115,"total_tps":20836.904985687703,"mean_input_tokens":1024.0,"mean_output_tokens":128.0,"ttft_p50_ms":1298.5604775021784,"ttft_p95_ms":3689.8819272406395,"ttft_p99_ms":3851.6867078171344,"tpot_p50_ms":27.635110685176503,"tpot_p95_ms":38.31963073893076,"tpot_p99_ms":40.49639800012086,"e2e_p50_ms":4722.0062784908805,"e2e_p95_ms":7185.337262970278,"e2e_p99_ms":7407.497151481803,"itl_p50_ms":25.355652993312106,"itl_p95_ms":28.420837520388886,"itl_p99_ms":44.460576775018,"validation_errors":[],"timestamp":"2026-07-19T03:57:58+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":128,"concurrency":96,"num_prompts":480,"warmup_requests":96,"attempt":1,"gain_pct":32.526005,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260719-033420/tp2_dp4/raw_outputs/sglang_adaptive_c96_i1024_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260719-033420/tp2_dp4/logs/sglang_c96_i1024_o128_a1.log"} +{"status":"COMPLETED","completed":560,"failed":0,"duration_s":34.746543716988526,"request_tps":16.11671090400283,"input_tps":16503.511965698897,"output_tps":2062.938995712362,"total_tps":18566.45096141126,"mean_input_tokens":1024.0,"mean_output_tokens":128.0,"ttft_p50_ms":608.3475205232389,"ttft_p95_ms":1558.8844810961743,"ttft_p99_ms":1583.548976209713,"tpot_p50_ms":46.581306712707416,"tpot_p95_ms":73.17983726150445,"tpot_p99_ms":75.91808525463621,"e2e_p50_ms":6738.658404006856,"e2e_p95_ms":9750.989388211747,"e2e_p99_ms":10053.312175953177,"itl_p50_ms":28.83477249997668,"itl_p95_ms":184.36487298749864,"itl_p99_ms":420.6771957303863,"validation_errors":[],"timestamp":"2026-07-19T03:59:15+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":128,"concurrency":112,"num_prompts":560,"warmup_requests":112,"attempt":1,"gain_pct":-10.896311,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260719-033420/tp2_dp4/raw_outputs/sglang_adaptive_c112_i1024_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260719-033420/tp2_dp4/logs/sglang_c112_i1024_o128_a1.log"} +{"status":"COMPLETED","completed":640,"failed":0,"duration_s":34.01491182798054,"request_tps":18.815277347670158,"input_tps":19266.84400401424,"output_tps":2408.35550050178,"total_tps":21675.199504516022,"mean_input_tokens":1024.0,"mean_output_tokens":128.0,"ttft_p50_ms":1045.4813955002464,"ttft_p95_ms":1658.5817171027882,"ttft_p99_ms":1748.6515575222438,"tpot_p50_ms":40.110978527511584,"tpot_p95_ms":77.36987587354167,"tpot_p99_ms":80.26658875081235,"e2e_p50_ms":5965.609657985624,"e2e_p95_ms":10343.119589690465,"e2e_p99_ms":10949.92640346114,"itl_p50_ms":29.082704975735396,"itl_p95_ms":109.70531427301484,"itl_p99_ms":422.99608536297586,"validation_errors":[],"timestamp":"2026-07-19T04:00:30+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":128,"concurrency":128,"num_prompts":640,"warmup_requests":128,"attempt":1,"gain_pct":16.743903,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260719-033420/tp2_dp4/raw_outputs/sglang_adaptive_c128_i1024_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260719-033420/tp2_dp4/logs/sglang_c128_i1024_o128_a1.log"} +{"status":"COMPLETED","completed":720,"failed":0,"duration_s":34.366635869955644,"request_tps":20.950552236899213,"input_tps":21453.365490584794,"output_tps":2681.6706863230993,"total_tps":24135.036176907895,"mean_input_tokens":1024.0,"mean_output_tokens":128.0,"ttft_p50_ms":1150.756682996871,"ttft_p95_ms":2164.658908988349,"ttft_p99_ms":2381.5159366774596,"tpot_p50_ms":41.69754042518399,"tpot_p95_ms":59.007043414267955,"tpot_p99_ms":66.51692086641903,"e2e_p50_ms":6361.816175980493,"e2e_p95_ms":8988.005556701683,"e2e_p99_ms":9219.872254310176,"itl_p50_ms":31.897266511805356,"itl_p95_ms":42.301298529491774,"itl_p99_ms":322.6426323468331,"validation_errors":[],"timestamp":"2026-07-19T04:01:50+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":128,"concurrency":144,"num_prompts":720,"warmup_requests":144,"attempt":1,"gain_pct":11.348623,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260719-033420/tp2_dp4/raw_outputs/sglang_adaptive_c144_i1024_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260719-033420/tp2_dp4/logs/sglang_c144_i1024_o128_a1.log"} +{"status":"COMPLETED","completed":800,"failed":0,"duration_s":38.98868205503095,"request_tps":20.518775137636926,"input_tps":21011.225740940212,"output_tps":2626.4032176175265,"total_tps":23637.62895855774,"mean_input_tokens":1024.0,"mean_output_tokens":128.0,"ttft_p50_ms":934.7565180214588,"ttft_p95_ms":2528.371806678478,"ttft_p99_ms":2753.671529366402,"tpot_p50_ms":45.89617406668904,"tpot_p95_ms":86.20793614137774,"tpot_p99_ms":93.7782083666887,"e2e_p50_ms":6956.718697969336,"e2e_p95_ms":11462.680733652078,"e2e_p99_ms":12598.600398967392,"itl_p50_ms":31.99835351551883,"itl_p95_ms":135.66492479876607,"itl_p99_ms":510.1641430531162,"validation_errors":[],"timestamp":"2026-07-19T04:03:15+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":128,"concurrency":160,"num_prompts":800,"warmup_requests":160,"attempt":1,"gain_pct":-2.060934,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260719-033420/tp2_dp4/raw_outputs/sglang_adaptive_c160_i1024_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260719-033420/tp2_dp4/logs/sglang_c160_i1024_o128_a1.log"} diff --git a/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260719-033420/adaptive_shapes.jsonl b/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260719-033420/adaptive_shapes.jsonl new file mode 100644 index 0000000..e69de29 diff --git a/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260719-033420/run_manifest.json b/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260719-033420/run_manifest.json new file mode 100644 index 0000000..56172cc --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260719-033420/run_manifest.json @@ -0,0 +1,27 @@ +{ + "experiment": "dsv4_dspark_h20_sglang_tp_dp_matrix", + "engine": "sglang", + "run_id": "adaptive_20260719-033420", + "model": "/data1/hf_models/DeepSeek-V4-Flash-DSpark", + "hardware": "8x NVIDIA H20 96GB", + "matrix": "/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/matrix.json", + "dataset": "random", + "tokenize_prompt": false, + "random_range_ratio": 1.0, + "search": { + "start_concurrency": 16, + "max_concurrency": 512, + "multiplier": 2, + "initial_backoff_concurrencies": [ + 8, + 1 + ], + "num_prompts_multiplier": 5, + "min_tps_gain_pct": 2.0, + "plateau_patience": 2, + "warmup_max_requests": 0, + "ttft_slo_ms": 4000.0, + "enable_ttft_slo_stop": 1, + "ttft_group_skip_ms": 8000.0 + } +} diff --git a/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260719-033420/shapes.tsv b/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260719-033420/shapes.tsv new file mode 100644 index 0000000..e1f82e6 --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260719-033420/shapes.tsv @@ -0,0 +1,40 @@ +mark input_len output_len +Y 1024 128 +Y 1024 256 +Y 1024 512 +Y 1024 1024 +Y 1024 2048 +Y 1024 4096 +Y 4096 128 +Y 4096 256 +Y 4096 512 +Y 4096 1024 +Y 4096 2048 +Y 4096 4096 +Y 8192 128 +Y 8192 256 +Y 8192 512 +Y 8192 1024 +Y 8192 2048 +Y 8192 4096 +Y 16384 128 +Y 16384 256 +Y 16384 512 +Y 16384 1024 +Y 16384 2048 +Y 32768 128 +Y 32768 256 +Y 32768 512 +Y 32768 1024 +Y 32768 2048 +Y 65536 128 +Y 65536 256 +Y 65536 512 +Y 65536 1024 +Y 131072 128 +Y 131072 256 +Y 131072 512 +Y 262144 128 +Y 262144 256 +Y 524288 128 +Y 1048576 128 diff --git a/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/compare.py b/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/compare.py new file mode 100644 index 0000000..fb348ce --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/compare.py @@ -0,0 +1,162 @@ +#!/usr/bin/env python3 +"""Cross TP×DP configuration comparison for dsv4_dspark_h20_sglang_tp_dp_matrix. + +Usage: + python3 compare.py --run-root results/ [--output comparison.md] +""" +import argparse +import json +import re +from collections import defaultdict +from pathlib import Path + + +def load_result(result_root: Path) -> dict: + path = result_root / "results.json" + with open(path, "r", encoding="utf-8") as f: + return json.load(f) + + +def slo_status(ttft_p95_ms: float, tpot_mean_ms: float, + ttft_limit_ms: float = 3000.0, tpot_limit_ms: float = 50.0) -> str: + ttft_ok = ttft_p95_ms < ttft_limit_ms + tpot_ok = tpot_mean_ms < tpot_limit_ms + if ttft_ok and tpot_ok: + return "PASS" + if ttft_ok or tpot_ok: + return "PARTIAL" + return "FAIL" + + +def gpu_memory_str(gpu: dict | None) -> str: + if not gpu: + return "-" + peak = gpu.get("peak_used_mb", 0) + total = gpu.get("memory_total_mb", 0) + if total: + return f"{peak:.0f}/{total:.0f} ({100*peak/total:.1f}%)" + return f"{peak:.0f}" + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--run-root", type=Path, required=True) + parser.add_argument("-o", "--output", type=Path, default=Path("comparison.md")) + parser.add_argument("--ttft-limit", type=float, default=3000.0) + parser.add_argument("--tpot-limit", type=float, default=50.0) + args = parser.parse_args() + + # Discover configurations: tp*_dp* directories. + configs = [] + for subdir in sorted(args.run_root.iterdir()): + if not subdir.is_dir(): + continue + name = subdir.name + if not (name.startswith("tp") and "_dp" in name): + continue + results_json = subdir / "results.json" + if not results_json.exists(): + continue + configs.append((name, load_result(subdir))) + + if not configs: + print(f"No tp*_dp* results found under {args.run_root}") + return + + model = configs[0][1].get("metadata", {}).get("model", "unknown") + hardware = configs[0][1].get("metadata", {}).get("hardware", "unknown") + + # Group by scenario name. + by_scenario: dict[str, dict[str, dict]] = defaultdict(dict) + skipped: dict[str, dict[str, str]] = defaultdict(dict) + for label, data in configs: + for s in data.get("scenarios", []): + key = s["name"] + if s.get("status") == "skipped_oom": + skipped[key][label] = s.get("note", "skipped") + else: + by_scenario[key][label] = s + + with open(args.output, "w", encoding="utf-8") as f: + f.write(f"# SGLang TP×DP matrix comparison ({hardware})\n\n") + f.write("## Summary\n\n") + f.write(f"- Model: `{model}`\n") + f.write(f"- Hardware: {hardware}\n") + f.write("- Backend: SGLang (Docker)\n") + f.write("- Benchmark client: `sglang.bench_serving`\n") + f.write(f"- SLO reference: TTFT P95 < {args.ttft_limit}ms, TPOT mean < {args.tpot_limit}ms\n\n") + + # Configuration overview. + f.write("### Configurations\n\n") + f.write("| Config | TP | DP | GPUs/replica | Notes |\n") + f.write("|---|---:|---:|---:|---|\n") + for label, data in configs: + cfg = data.get("config", {}) + tp = cfg.get("tp", "?") + dp = cfg.get("dp", "?") + f.write(f"| {label} | {tp} | {dp} | {tp} | server args recorded per ISL in results.json |\n") + f.write("\n") + + # Side-by-side table. + f.write("## Side-by-side results\n\n") + headers = [ + "Scenario", "ISL", "OSL", "Config", "Conc", "Req/s", "OutTok/s", + "TTFT P95(ms)", "TTFT P99(ms)", "TPOT Mean(ms)", "TPOT P95(ms)", + "TPOT P99(ms)", "E2E P99(ms)", "Peak GPU mem", "SLO" + ] + f.write("| " + " | ".join(headers) + " |\n") + f.write("|" + "|".join(["---"] * len(headers)) + "|\n") + + for scenario_name in sorted(by_scenario.keys(), key=lambda x: tuple(map(int, re.findall(r"\d+", x)))): + _, isl, osl = re.findall(r"\d+", scenario_name) + for label, data in configs: + s = by_scenario[scenario_name].get(label) + if s is None: + if scenario_name in skipped and label in skipped[scenario_name]: + note = skipped[scenario_name][label] + f.write(f"| {scenario_name} | {isl} | {osl} | {label} | - | - | - | - | - | - | - | - | - | - | {note} |\n") + continue + cfg = s["config"] + m = s["metrics"] + status = slo_status(m["ttft_ms"]["p95"], m["tpot_ms"]["mean"], args.ttft_limit, args.tpot_limit) + gpu = m.get("gpu_memory") + f.write( + f"| {scenario_name} | {isl} | {osl} | {label} | {cfg['concurrency']} | " + f"{m['request_throughput']:.2f} | {m['output_token_throughput']:.2f} | " + f"{m['ttft_ms']['p95']:.2f} | {m['ttft_ms']['p99']:.2f} | " + f"{m['tpot_ms']['mean']:.2f} | {m['tpot_ms']['p95']:.2f} | {m['tpot_ms']['p99']:.2f} | " + f"{m['e2e_ms']['p99']:.2f} | {gpu_memory_str(gpu)} | {status} |\n" + ) + + # Best throughput per ISL/OSL. + f.write("\n## Best throughput per (ISL, OSL)\n\n") + f.write("| ISL | OSL | Best Config | Concurrency | OutTok/s | TTFT P95(ms) | TPOT Mean(ms) | SLO |\n") + f.write("|---:|---:|---|---:|---:|---:|---:|---:|\n") + best_by_shape: dict[tuple[int, int], tuple[float, str, dict]] = {} + for scenario_name, backends in by_scenario.items(): + _, isl, osl = re.findall(r"\d+", scenario_name) + isl_i, osl_i = int(isl), int(osl) + for label, s in backends.items(): + m = s["metrics"] + out_tok = m["output_token_throughput"] + if (isl_i, osl_i) not in best_by_shape or out_tok > best_by_shape[(isl_i, osl_i)][0]: + best_by_shape[(isl_i, osl_i)] = (out_tok, label, s) + for (isl_i, osl_i), (out_tok, label, s) in sorted(best_by_shape.items()): + m = s["metrics"] + status = slo_status(m["ttft_ms"]["p95"], m["tpot_ms"]["mean"], args.ttft_limit, args.tpot_limit) + f.write( + f"| {isl_i} | {osl_i} | {label} | {s['config']['concurrency']} | " + f"{out_tok:.2f} | {m['ttft_ms']['p95']:.2f} | {m['tpot_ms']['mean']:.2f} | {status} |\n" + ) + + f.write("\n## Notes\n\n") + f.write("- SLO check uses TTFT P95 and TPOT mean.\n") + f.write("- A PARTIAL indicates one of the two metrics is out of target; FAIL indicates both are out.\n") + f.write("- `Peak GPU mem` shows peak used / total MB and utilization percentage.\n") + f.write("- Optional (P) combinations that failed are marked as skipped/OOM and do not break the run.\n") + + print(f"Wrote comparison to {args.output}") + + +if __name__ == "__main__": + main() diff --git a/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/config.env b/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/config.env new file mode 100644 index 0000000..7f96f2a --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/config.env @@ -0,0 +1,70 @@ +# TP×DP matrix experiment for DeepSeek-V4-Flash-DSpark on H20 (8 GPUs) using SGLang. +# Tests SGLang with three parallel configurations: +# TP=2, DP=4 -> 2 GPUs per replica, 4 replicas +# TP=4, DP=2 -> 4 GPUs per replica, 2 replicas +# TP=8, DP=1 -> 8 GPUs, no data parallelism + +EXPERIMENT="dsv4_dspark_h20_sglang_tp_dp_matrix" +MODEL_NAME="DeepSeek-V4-Flash-DSpark" +MODEL_PATH="/data1/hf_models/DeepSeek-V4-Flash-DSpark" +SERVED_MODEL_NAME="deepseek-v4-flash-dspark" + +SGLANG_PORT="${SGLANG_PORT:-30033}" + +# Python interpreter for orchestration scripts (parse_backend.py, compare.py, etc.) +# and the benchmark client. Defaults to the system python3 if the sglang venv +# does not exist on the host. +VENV_CLIENT="${VENV_CLIENT:-/data1/yy/sskj/envs/sglang}" + +# Run the benchmark client natively (0) or inside Docker (1). +USE_DOCKER_CLIENT="${USE_DOCKER_CLIENT:-1}" + +export CUDA_VISIBLE_DEVICES="${CUDA_VISIBLE_DEVICES:-0,1,2,3,4,5,6,7}" + +# Runtime working directory for logs, pid files, and tmp. Defaults to a local +# directory under this experiment so the benchmark is self-contained. +RUNTIME_BASE="${RUNTIME_BASE:-${SCRIPT_DIR}/runtime}" + +# Parallel configurations to test. Format: "TP DP" +declare -a PARALLEL_CONFIGS=( + "2 4" + "4 2" + "8 1" +) + +# SGLang server settings +CONTEXT_LENGTH="${CONTEXT_LENGTH:-1048576}" +MAX_RUNNING_REQUESTS="${MAX_RUNNING_REQUESTS:-128}" +MEM_FRACTION_STATIC="${MEM_FRACTION_STATIC:-0.88}" +MOE_RUNNER_BACKEND="${MOE_RUNNER_BACKEND:-marlin}" + +# Deployment switch. 0 = native sglang venv, 1 = Docker. +USE_DOCKER="${USE_DOCKER:-1}" +DOCKER_IMAGE="${DOCKER_IMAGE:-lmsysorg/sglang:latest}" + +# Dataset used by sglang.bench_serving --dataset-name random. +# The random sampler needs a ShareGPT-style JSON file locally; it falls back to +# downloading from HuggingFace, which usually fails on offline H20 nodes. +DATASET_PATH="${DATASET_PATH:-/data1/yy/sskj/datasets/ShareGPT_V3_unfiltered_cleaned_split.json}" + +# Matrix and concurrency rules are defined in matrix.json by default. +MATRIX_FILE="${MATRIX_FILE:-${SCRIPT_DIR:-.}/matrix.json}" +MATRIX_MODE="${MATRIX_MODE:-Y}" + +# Sampling density for concurrency. +# 0 = use the default heuristic in generate_scenarios.py (6-8 points). +# 2 = only test the low and high endpoints. +export CONCURRENCY_SAMPLES="${CONCURRENCY_SAMPLES:-2}" + +# Per-scenario timeout to avoid hangs (seconds). +SCENARIO_TIMEOUT_S="${SCENARIO_TIMEOUT_S:-1800}" + +# GPU memory sampling interval (seconds). +GPU_MEM_SAMPLE_INTERVAL_S="${GPU_MEM_SAMPLE_INTERVAL_S:-1}" + +# Dry-run mode: if 1, only log the server args and scenario plan without starting +# any server or sending requests. +DRY_RUN="${DRY_RUN:-0}" + +# Per-config scenario limit for quick smoke tests. 0 = run all generated scenarios. +GRID_LIMIT="${GRID_LIMIT:-0}" diff --git a/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/generate_scenarios.py b/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/generate_scenarios.py new file mode 100644 index 0000000..2bfb152 --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/generate_scenarios.py @@ -0,0 +1,98 @@ +#!/usr/bin/env python3 +"""Generate the scenario list for the TP×DP matrix experiment. + +Reads matrix.json and prints TSV lines: + + mark input_len output_len concurrency num_prompts + +mark is one of Y/P/N. The caller (run_bench.sh) decides how to treat each. +""" +import argparse +import json +import math +import os +from pathlib import Path + + +def sample_concurrency(low: int, high: int, target: int) -> list[int]: + """Return only the low and high concurrency values in [low, high]. + + For the TP×DP matrix we only need the two endpoints of the concurrency + range (e.g. 1 and 128 for ISL=1024). The `target` argument is kept for + API compatibility but is ignored. + """ + assert 1 <= low <= high, f"invalid concurrency range: {low}-{high}" + if low == high: + return [low] + return [low, high] + + +def generate_scenarios(matrix_path: Path, mode: str, target_samples: int) -> list[dict]: + with open(matrix_path, "r", encoding="utf-8") as f: + data = json.load(f) + + matrix = data["matrix"] + concurrency_cfg = data["concurrency"] + + scenarios = [] + for isl_str in sorted(matrix.keys(), key=int): + osl_map = matrix[isl_str] + low = concurrency_cfg[isl_str]["low"] + high = concurrency_cfg[isl_str]["high"] + concurrencies = sample_concurrency(low, high, target_samples) + + for osl_str in sorted(osl_map.keys(), key=int): + mark = osl_map[osl_str] + if mode == "Y" and mark != "Y": + continue + if mode == "Y+P" and mark not in ("Y", "P"): + continue + # mode == "all" keeps everything, including N. + + for conc in concurrencies: + scenarios.append( + { + "mark": mark, + "input_len": int(isl_str), + "output_len": int(osl_str), + "concurrency": conc, + "num_prompts": conc * 5, + } + ) + + return scenarios + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--matrix", type=Path, default=Path("matrix.json")) + parser.add_argument("--mode", choices=["Y", "Y+P", "all"], default=None, + help="Scenario selection mode. Defaults to matrix.mode.") + parser.add_argument("--target-samples", type=int, default=0, + help="Target number of concurrency samples. 0 = heuristic (6-8).") + args = parser.parse_args() + + with open(args.matrix, "r", encoding="utf-8") as f: + data = json.load(f) + + mode = args.mode if args.mode else data.get("mode", "Y+P") + + target_samples = args.target_samples + if target_samples <= 0: + env_samples = os.getenv("CONCURRENCY_SAMPLES", "0") + try: + target_samples = int(env_samples) + except ValueError: + target_samples = 0 + if target_samples <= 0: + target_samples = 7 + + scenarios = generate_scenarios(args.matrix, mode, target_samples) + + print("mark\tinput_len\toutput_len\tconcurrency\tnum_prompts") + for s in scenarios: + print(f"{s['mark']}\t{s['input_len']}\t{s['output_len']}\t{s['concurrency']}\t{s['num_prompts']}") + + +if __name__ == "__main__": + main() diff --git a/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/matrix.json b/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/matrix.json new file mode 100644 index 0000000..dfc7572 --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/matrix.json @@ -0,0 +1,128 @@ +{ + "comment": "Only mandatory (Y) combinations are tested; 1M ISL is excluded per user request.", + "mode": "Y", + "matrix": { + "1024": { + "128": "Y", + "256": "Y", + "512": "Y", + "1024": "Y", + "2048": "Y", + "4096": "Y" + }, + "4096": { + "128": "Y", + "256": "Y", + "512": "Y", + "1024": "Y", + "2048": "Y", + "4096": "Y" + }, + "8192": { + "128": "Y", + "256": "Y", + "512": "Y", + "1024": "Y", + "2048": "Y", + "4096": "Y" + }, + "16384": { + "128": "Y", + "256": "Y", + "512": "Y", + "1024": "Y", + "2048": "Y", + "4096": "P" + }, + "32768": { + "128": "Y", + "256": "Y", + "512": "Y", + "1024": "Y", + "2048": "Y", + "4096": "P" + }, + "65536": { + "128": "Y", + "256": "Y", + "512": "Y", + "1024": "Y", + "2048": "P", + "4096": "N" + }, + "131072": { + "128": "Y", + "256": "Y", + "512": "Y", + "1024": "P", + "2048": "N", + "4096": "N" + }, + "262144": { + "128": "Y", + "256": "Y", + "512": "P", + "1024": "N", + "2048": "N", + "4096": "N" + }, + "524288": { + "128": "Y", + "256": "P", + "512": "N", + "1024": "N", + "2048": "N", + "4096": "N" + }, + "1048576": { + "128": "Y", + "256": "P", + "512": "N", + "1024": "N", + "2048": "N", + "4096": "N" + } + }, + "concurrency": { + "1024": { + "low": 1, + "high": 128 + }, + "4096": { + "low": 1, + "high": 64 + }, + "8192": { + "low": 1, + "high": 64 + }, + "16384": { + "low": 1, + "high": 32 + }, + "32768": { + "low": 1, + "high": 16 + }, + "65536": { + "low": 1, + "high": 8 + }, + "131072": { + "low": 1, + "high": 4 + }, + "262144": { + "low": 1, + "high": 2 + }, + "524288": { + "low": 1, + "high": 2 + }, + "1048576": { + "low": 1, + "high": 2 + } + } +} diff --git a/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/run_adaptive_concurrency.sh b/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/run_adaptive_concurrency.sh new file mode 100755 index 0000000..7972a9e --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/run_adaptive_concurrency.sh @@ -0,0 +1,181 @@ +#!/usr/bin/env bash +# Find the Total-TPS saturation concurrency for each SGLang TP/DP/ISL/OSL shape. +set -Eeuo pipefail + +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +EXPERIMENT_NAME="$(basename "$SCRIPT_DIR")" + +# shellcheck source=/dev/null +source "${SCRIPT_DIR}/../../../scripts/common/lib.sh" +# shellcheck source=/dev/null +source "${SCRIPT_DIR}/../../../scripts/common/platform.sh" +# shellcheck source=/dev/null +source "${SCRIPT_DIR}/config.env" +# shellcheck source=/dev/null +source "${SCRIPT_DIR}/adaptive_config.env" +# shellcheck source=/dev/null +source "${SCRIPT_DIR}/../../../scripts/common/adaptive_bench_lib.sh" + +ENGINE="sglang" +ENGINE_PORT="$SGLANG_PORT" +RESULT_BASE="${RESULT_BASE:-${SCRIPT_DIR}/adaptive_results}" +ACTIVE_ENGINE_SERVER_LOG="" + +if [[ -x "${VENV_CLIENT}/bin/python" ]]; then + PYTHON="${VENV_CLIENT}/bin/python" +else + PYTHON="$(command -v python3)" +fi + +DOCKER_IMAGE="${DOCKER_IMAGE:-lmsysorg/sglang:latest}" + +engine_is_healthy() { + curl --fail --silent --show-error --max-time 5 \ + "http://127.0.0.1:${ENGINE_PORT}/health" >/dev/null 2>&1 +} + +engine_stop_server() { + local tp="$1" + local dp="$2" + local pid_file="${RUNTIME_BASE}/${EXPERIMENT}_sglang_tp${tp}_dp${dp}.pid" + + if [[ -f "$pid_file" ]]; then + local pid + pid="$(cat "$pid_file")" + if [[ -n "${CONTAINER_NAME:-}" ]]; then + if docker exec "$CONTAINER_NAME" kill -0 "$pid" 2>/dev/null; then + log "stopping sglang in persistent container pid=${pid} tp=${tp} dp=${dp}" + docker exec "$CONTAINER_NAME" kill "$pid" 2>/dev/null || true + sleep 5 + docker exec "$CONTAINER_NAME" kill -9 "$pid" 2>/dev/null || true + fi + elif kill -0 "$pid" 2>/dev/null; then + log "stopping sglang server pid=${pid} tp=${tp} dp=${dp}" + kill "$pid" 2>/dev/null || true + sleep 5 + kill -9 "$pid" 2>/dev/null || true + fi + rm -f "$pid_file" + fi + if [[ -z "${CONTAINER_NAME:-}" ]]; then + docker rm -f "${EXPERIMENT}_sglang_tp${tp}_dp${dp}" >/dev/null 2>&1 || true + fi + ACTIVE_ENGINE_SERVER_LOG="" + sleep 2 +} + +engine_build_server_args() { + local tp="$1" + local dp="$2" + local -a args=( + sglang serve --model-path "$MODEL_PATH" + --trust-remote-code + --tp-size "$tp" + --moe-runner-backend "$MOE_RUNNER_BACKEND" + --context-length "$CONTEXT_LENGTH" + --max-running-requests "$MAX_RUNNING_REQUESTS" + --mem-fraction-static "$MEM_FRACTION_STATIC" + --host 0.0.0.0 + --port "$ENGINE_PORT" + ) + if (( dp > 1 )); then + args+=(--dp-size "$dp") + fi + printf '%q ' "${args[@]}" +} + +engine_start_server() { + local tp="$1" + local dp="$2" + local outer_log="${ADAPTIVE_LOG_DIR}/sglang_tp${tp}_dp${dp}.server.outer.log" + log "starting sglang server tp=${tp} dp=${dp}" + if [[ -n "${CONTAINER_NAME:-}" ]]; then + bash "${SCRIPT_DIR}/run_sglang_in_container.sh" "$tp" "$dp" >> "$outer_log" 2>&1 + else + bash "${SCRIPT_DIR}/start_sglang_dp.sh" "$tp" "$dp" >> "$outer_log" 2>&1 + fi + if ! engine_is_healthy; then + log "ERROR: sglang health check failed tp=${tp} dp=${dp}" + return 1 + fi + if [[ -z "${CONTAINER_NAME:-}" ]]; then + ACTIVE_ENGINE_SERVER_LOG="$( + find "${RUNTIME_BASE}/logs" -maxdepth 1 -type f \ + -name "${EXPERIMENT}_sglang*tp${tp}_dp${dp}_*.log" \ + -printf '%T@ %p\n' 2>/dev/null | sort -nr | head -n 1 | cut -d' ' -f2- + )" + fi + log "sglang server healthy tp=${tp} dp=${dp} log=${ACTIVE_ENGINE_SERVER_LOG:-container:/tmp/sglang_server.log}" +} + +engine_detect_oom() { + local detail_log="$1" + local tp="$2" + local dp="$3" + local pattern='CUDA out of memory|torch\.OutOfMemoryError|OutOfMemory|out of memory|OOM|RESOURCE_EXHAUSTED|Failed to allocate memory' + local outer_log="${ADAPTIVE_LOG_DIR}/sglang_tp${tp}_dp${dp}.server.outer.log" + local -a logs=("$detail_log" "$outer_log") + if [[ -n "$ACTIVE_ENGINE_SERVER_LOG" ]]; then + logs+=("$ACTIVE_ENGINE_SERVER_LOG") + fi + if grep -Eiq "$pattern" "${logs[@]}" 2>/dev/null; then + return 0 + fi + if [[ -n "${CONTAINER_NAME:-}" ]]; then + docker exec "$CONTAINER_NAME" grep -Eiq "$pattern" /tmp/sglang_server.log 2>/dev/null + return $? + fi + return 1 +} + +engine_run_bench() { + local isl="$1" + local osl="$2" + local concurrency="$3" + local num_prompts="$4" + local output_file="$5" + local warmup_requests + warmup_requests="$(adaptive_warmup_request_count "$concurrency")" + local -a bench_args=( + --backend sglang + --host 127.0.0.1 + --port "$ENGINE_PORT" + --dataset-name "$BENCH_DATASET_NAME" + --random-input-len "$isl" + --random-output-len "$osl" + --random-range-ratio "$RANDOM_RANGE_RATIO" + --num-prompts "$num_prompts" + --max-concurrency "$concurrency" + --request-rate 10000 + --warmup-requests "$warmup_requests" + --output-file "$output_file" + --output-details + --disable-tqdm + ) + if [[ "$BENCH_DATASET_NAME" == "random" ]]; then + bench_args+=(--dataset-path "$DATASET_PATH") + else + bench_args+=(--tokenize-prompt) + fi + + if [[ "$USE_DOCKER_CLIENT" == "1" ]]; then + local -a volume_args=(-v "${MODEL_PATH}:${MODEL_PATH}:ro" -v "${RESULT_BASE}:${RESULT_BASE}") + if [[ "$BENCH_DATASET_NAME" == "random" ]]; then + volume_args+=(-v "${DATASET_PATH}:${DATASET_PATH}:ro") + fi + docker run --rm \ + --network host \ + "${volume_args[@]}" \ + -e PYTHONUNBUFFERED=1 \ + "$DOCKER_IMAGE" \ + python -m sglang.bench_serving "${bench_args[@]}" + else + "$PYTHON" -m sglang.bench_serving "${bench_args[@]}" + fi +} + +export -f engine_run_bench +export ENGINE_PORT MODEL_PATH RESULT_BASE DOCKER_IMAGE USE_DOCKER_CLIENT +export BENCH_DATASET_NAME DATASET_PATH RANDOM_RANGE_RATIO BENCH_WARMUP_MAX_REQUESTS PYTHON + +adaptive_main "$@" diff --git a/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/run_adaptive_concurrency_add16.sh b/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/run_adaptive_concurrency_add16.sh new file mode 100755 index 0000000..c98b531 --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/run_adaptive_concurrency_add16.sh @@ -0,0 +1,190 @@ +#!/usr/bin/env bash +# Find the Total-TPS saturation concurrency for each SGLang TP/DP/ISL/OSL shape. +set -Eeuo pipefail + +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +EXPERIMENT_NAME="$(basename "$SCRIPT_DIR")" + +# shellcheck source=/dev/null +source "${SCRIPT_DIR}/../../../scripts/common/lib.sh" +# shellcheck source=/dev/null +source "${SCRIPT_DIR}/../../../scripts/common/platform.sh" +# shellcheck source=/dev/null +source "${SCRIPT_DIR}/config.env" +# shellcheck source=/dev/null +source "${SCRIPT_DIR}/adaptive_config.env" +# shellcheck source=/dev/null +source "${SCRIPT_DIR}/../../../scripts/common/adaptive_bench_lib.sh" + +ENGINE="sglang" +ENGINE_PORT="$SGLANG_PORT" +RESULT_BASE="${RESULT_BASE:-${SCRIPT_DIR}/adaptive_results}" +ACTIVE_ENGINE_SERVER_LOG="" + +if [[ -x "${VENV_CLIENT}/bin/python" ]]; then + PYTHON="${VENV_CLIENT}/bin/python" +else + PYTHON="$(command -v python3)" +fi + +DOCKER_IMAGE="${DOCKER_IMAGE:-lmsysorg/sglang:latest}" + +engine_is_healthy() { + curl --fail --silent --show-error --max-time 5 \ + "http://127.0.0.1:${ENGINE_PORT}/health" >/dev/null 2>&1 +} + +engine_stop_server() { + local tp="$1" + local dp="$2" + local pid_file="${RUNTIME_BASE}/${EXPERIMENT}_sglang_tp${tp}_dp${dp}.pid" + + if [[ -f "$pid_file" ]]; then + local pid + pid="$(cat "$pid_file")" + if [[ -n "${CONTAINER_NAME:-}" ]]; then + if docker exec "$CONTAINER_NAME" kill -0 "$pid" 2>/dev/null; then + log "stopping sglang in persistent container pid=${pid} tp=${tp} dp=${dp}" + docker exec "$CONTAINER_NAME" kill "$pid" 2>/dev/null || true + sleep 5 + docker exec "$CONTAINER_NAME" kill -9 "$pid" 2>/dev/null || true + fi + elif kill -0 "$pid" 2>/dev/null; then + log "stopping sglang server pid=${pid} tp=${tp} dp=${dp}" + kill "$pid" 2>/dev/null || true + sleep 5 + kill -9 "$pid" 2>/dev/null || true + fi + rm -f "$pid_file" + fi + if [[ -z "${CONTAINER_NAME:-}" ]]; then + docker rm -f "${EXPERIMENT}_sglang_tp${tp}_dp${dp}" >/dev/null 2>&1 || true + fi + ACTIVE_ENGINE_SERVER_LOG="" + sleep 2 +} + +engine_build_server_args() { + local tp="$1" + local dp="$2" + local -a args=( + sglang serve --model-path "$MODEL_PATH" + --trust-remote-code + --tp-size "$tp" + --moe-runner-backend "$MOE_RUNNER_BACKEND" + --context-length "$CONTEXT_LENGTH" + --max-running-requests "$MAX_RUNNING_REQUESTS" + --mem-fraction-static "$MEM_FRACTION_STATIC" + --host 0.0.0.0 + --port "$ENGINE_PORT" + ) + if (( dp > 1 )); then + args+=(--dp-size "$dp") + fi + printf '%q ' "${args[@]}" +} + +engine_start_server() { + local tp="$1" + local dp="$2" + local outer_log="${ADAPTIVE_LOG_DIR}/sglang_tp${tp}_dp${dp}.server.outer.log" + log "starting sglang server tp=${tp} dp=${dp}" + if [[ -n "${CONTAINER_NAME:-}" ]]; then + bash "${SCRIPT_DIR}/run_sglang_in_container.sh" "$tp" "$dp" >> "$outer_log" 2>&1 + else + bash "${SCRIPT_DIR}/start_sglang_dp.sh" "$tp" "$dp" >> "$outer_log" 2>&1 + fi + if ! engine_is_healthy; then + log "ERROR: sglang health check failed tp=${tp} dp=${dp}" + return 1 + fi + if [[ -z "${CONTAINER_NAME:-}" ]]; then + ACTIVE_ENGINE_SERVER_LOG="$( + find "${RUNTIME_BASE}/logs" -maxdepth 1 -type f \ + -name "${EXPERIMENT}_sglang*tp${tp}_dp${dp}_*.log" \ + -printf '%T@ %p\n' 2>/dev/null | sort -nr | head -n 1 | cut -d' ' -f2- + )" + fi + log "sglang server healthy tp=${tp} dp=${dp} log=${ACTIVE_ENGINE_SERVER_LOG:-container:/tmp/sglang_server.log}" +} + +engine_detect_oom() { + local detail_log="$1" + local tp="$2" + local dp="$3" + local pattern='CUDA out of memory|torch\.OutOfMemoryError|OutOfMemory|out of memory|OOM|RESOURCE_EXHAUSTED|Failed to allocate memory' + local outer_log="${ADAPTIVE_LOG_DIR}/sglang_tp${tp}_dp${dp}.server.outer.log" + local -a logs=("$detail_log" "$outer_log") + if [[ -n "$ACTIVE_ENGINE_SERVER_LOG" ]]; then + logs+=("$ACTIVE_ENGINE_SERVER_LOG") + fi + if grep -Eiq "$pattern" "${logs[@]}" 2>/dev/null; then + return 0 + fi + if [[ -n "${CONTAINER_NAME:-}" ]]; then + docker exec "$CONTAINER_NAME" grep -Eiq "$pattern" /tmp/sglang_server.log 2>/dev/null + return $? + fi + return 1 +} + +engine_run_bench() { + local isl="$1" + local osl="$2" + local concurrency="$3" + local num_prompts="$4" + local output_file="$5" + local warmup_requests + warmup_requests="$(adaptive_warmup_request_count "$concurrency")" + local -a bench_args=( + --backend sglang + --host 127.0.0.1 + --port "$ENGINE_PORT" + --dataset-name "$BENCH_DATASET_NAME" + --random-input-len "$isl" + --random-output-len "$osl" + --random-range-ratio "$RANDOM_RANGE_RATIO" + --num-prompts "$num_prompts" + --max-concurrency "$concurrency" + --request-rate 10000 + --warmup-requests "$warmup_requests" + --output-file "$output_file" + --output-details + --disable-tqdm + ) + if [[ "$BENCH_DATASET_NAME" == "random" ]]; then + bench_args+=(--dataset-path "$DATASET_PATH") + else + bench_args+=(--tokenize-prompt) + fi + + if [[ "$USE_DOCKER_CLIENT" == "1" ]]; then + local -a volume_args=(-v "${MODEL_PATH}:${MODEL_PATH}:ro" -v "${RESULT_BASE}:${RESULT_BASE}") + if [[ "$BENCH_DATASET_NAME" == "random" ]]; then + volume_args+=(-v "${DATASET_PATH}:${DATASET_PATH}:ro") + fi + docker run --rm \ + --network host \ + "${volume_args[@]}" \ + -e PYTHONUNBUFFERED=1 \ + "$DOCKER_IMAGE" \ + python -m sglang.bench_serving "${bench_args[@]}" + else + "$PYTHON" -m sglang.bench_serving "${bench_args[@]}" + fi +} + +export -f engine_run_bench +export ENGINE_PORT MODEL_PATH RESULT_BASE DOCKER_IMAGE USE_DOCKER_CLIENT +export BENCH_DATASET_NAME DATASET_PATH RANDOM_RANGE_RATIO BENCH_WARMUP_MAX_REQUESTS PYTHON + +export SEARCH_START_CONCURRENCY=16 +export SEARCH_ADDEND=16 +# If the initial concurrency violates the TTFT SLO, search downward. Stop at +# the first acceptable value (16 -> 8; only try 1 when 8 still violates it). +export SEARCH_INITIAL_BACKOFF_CONCURRENCIES="8 1" +# When concurrency 1 still has a severely excessive TTFT, stop the remaining +# shapes in this TP/DP group. Zero disables this rule. +export TTFT_GROUP_SKIP_MS="${TTFT_GROUP_SKIP_MS:-8000}" + +adaptive_main "$@" diff --git a/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/run_bench.sh b/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/run_bench.sh new file mode 100755 index 0000000..36cfbba --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/run_bench.sh @@ -0,0 +1,560 @@ +#!/usr/bin/env bash +# TP×DP matrix benchmark for DeepSeek-V4-Flash-DSpark on SGLang (Docker). +set -Eeuo pipefail + +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +EXPERIMENT_NAME="$(basename "$SCRIPT_DIR")" + +# shellcheck source=/dev/null +source "${SCRIPT_DIR}/../../../scripts/common/lib.sh" +# shellcheck source=/dev/null +source "${SCRIPT_DIR}/../../../scripts/common/platform.sh" +# shellcheck source=/dev/null +source "${SCRIPT_DIR}/config.env" + +RUN_ID="${RUN_ID:-$(date '+%Y%m%d-%H%M%S')}" +RESULT_BASE="${SCRIPT_DIR}/results" +MATRIX_FILE="${MATRIX_FILE:-${SCRIPT_DIR}/matrix.json}" +MATRIX_MODE="${MATRIX_MODE:-Y}" +SCENARIO_TIMEOUT_S="${SCENARIO_TIMEOUT_S:-1800}" +GPU_MEM_SAMPLE_INTERVAL_S="${GPU_MEM_SAMPLE_INTERVAL_S:-1}" +DRY_RUN="${DRY_RUN:-0}" +GRID_LIMIT="${GRID_LIMIT:-0}" + +# Export variables used inside functions that are called via bash -c subshells. +export DATASET_PATH MODEL_PATH RESULT_BASE DOCKER_IMAGE USE_DOCKER_CLIENT + +if [[ -x "${VENV_CLIENT}/bin/python" ]]; then + PYTHON="${VENV_CLIENT}/bin/python" +else + PYTHON="$(command -v python3)" +fi + +DOCKER_IMAGE="${DOCKER_IMAGE:-lmsysorg/sglang:latest}" + +log_dir_global="${RESULT_BASE}/${RUN_ID}/logs" +mkdir -p "$log_dir_global" +log_init "${log_dir_global}/orchestrator.log" + +log "experiment=${EXPERIMENT_NAME} run_id=${RUN_ID} platform=${PLATFORM} hardware=${HARDWARE}" +log "matrix_mode=${MATRIX_MODE} matrix_file=${MATRIX_FILE} dry_run=${DRY_RUN} grid_limit=${GRID_LIMIT}" + +# --------------------------------------------------------------------------- +# Helpers +# --------------------------------------------------------------------------- + +is_server_healthy() { + curl --fail --silent --show-error --max-time 5 "http://127.0.0.1:${SGLANG_PORT}/health" >/dev/null 2>&1 +} + +stop_server() { + local tp="$1" + local dp="$2" + + local pid_file="${RUNTIME_BASE}/${EXPERIMENT}_sglang_tp${tp}_dp${dp}.pid" + if [[ -f "$pid_file" ]]; then + local pid + pid="$(cat "$pid_file")" + # In container-reuse mode, pid is the server PID inside the container. + if [[ -n "${CONTAINER_NAME:-}" ]]; then + if docker exec "$CONTAINER_NAME" kill -0 "$pid" 2>/dev/null; then + log "stopping sglang server inside container (tp=${tp}, dp=${dp}, pid=${pid})" + docker exec "$CONTAINER_NAME" kill "$pid" 2>/dev/null || true + sleep 5 + docker exec "$CONTAINER_NAME" kill -9 "$pid" 2>/dev/null || true + fi + else + if kill -0 "$pid" 2>/dev/null; then + log "stopping sglang server pid=${pid} (tp=${tp}, dp=${dp})" + kill "$pid" 2>/dev/null || true + sleep 5 + kill -9 "$pid" 2>/dev/null || true + fi + fi + rm -f "$pid_file" + fi + + # Fallback: remove any Docker container started by this experiment (legacy mode). + if [[ -z "${CONTAINER_NAME:-}" ]]; then + docker rm -f "${EXPERIMENT}_sglang_tp${tp}_dp${dp}" >/dev/null 2>&1 || true + fi + + # Fallback: kill any sglang serve processes for this model. + pkill -9 -f "sglang serve.*${MODEL_NAME}" 2>/dev/null || true + pkill -9 -f "sglang serve.*${MODEL_PATH}" 2>/dev/null || true + sleep 2 +} + +build_server_args() { + local tp="$1" + local dp="$2" + + local args=( + "sglang serve" "$MODEL_PATH" + --trust-remote-code + --tp-size "$tp" + --moe-runner-backend "$MOE_RUNNER_BACKEND" + --context-length "$CONTEXT_LENGTH" + --max-running-requests "$MAX_RUNNING_REQUESTS" + --mem-fraction-static "$MEM_FRACTION_STATIC" + --host 0.0.0.0 + --port "$SGLANG_PORT" + ) + if [[ "$dp" -gt 1 ]]; then + args+=( + --dp-size "$dp" + ) + fi + printf '%s ' "${args[@]}" +} + +start_server() { + local tp="$1" + local dp="$2" + + log "starting sglang server tp=${tp} dp=${dp}" + if [[ -n "${CONTAINER_NAME:-}" ]]; then + bash "${SCRIPT_DIR}/run_sglang_in_container.sh" "$tp" "$dp" \ + >> "${log_dir_global}/sglang_tp${tp}_dp${dp}.server.outer.log" 2>&1 + else + bash "${SCRIPT_DIR}/start_sglang_dp.sh" "$tp" "$dp" \ + >> "${log_dir_global}/sglang_tp${tp}_dp${dp}.server.outer.log" 2>&1 + fi + + if ! is_server_healthy; then + log "error: sglang server tp=${tp} dp=${dp} failed health check on port ${SGLANG_PORT}" + return 1 + fi + log "sglang server tp=${tp} dp=${dp} is healthy on port ${SGLANG_PORT}" +} + +restart_server() { + local tp="$1" + local dp="$2" + log "restarting sglang server tp=${tp} dp=${dp} after non-OOM failure" + stop_server "$tp" "$dp" + sleep 10 + start_server "$tp" "$dp" +} + +run_bench_serving() { + # Run sglang.bench_serving either natively or inside the SGLang Docker image. + if [[ "${USE_DOCKER_CLIENT:-1}" == "1" ]]; then + local vol_args=() + vol_args+=("-v" "${MODEL_PATH}:${MODEL_PATH}:ro") + if [[ -n "${DATASET_PATH:-}" ]]; then + vol_args+=("-v" "${DATASET_PATH}:${DATASET_PATH}:ro") + fi + vol_args+=("-v" "${RESULT_BASE}:${RESULT_BASE}") + docker run --rm \ + --network host \ + "${vol_args[@]}" \ + -e PYTHONUNBUFFERED=1 \ + "${DOCKER_IMAGE}" \ + python -m sglang.bench_serving "$@" + else + "$PYTHON" -m sglang.bench_serving "$@" + fi +} +export -f run_bench_serving + +run_warmup() { + local input_len="$1" + local output_len="$2" + + log "warming up (input=${input_len}, output=${output_len}, num=5)" + bash -c ' + run_bench_serving \ + --backend sglang \ + --host 127.0.0.1 \ + --port "'"$SGLANG_PORT"'" \ + --dataset-name random \ + --dataset-path "'"$DATASET_PATH"'" \ + --random-input-len "'"$input_len"'" \ + --random-output-len "'"$output_len"'" \ + --num-prompts 5 \ + --max-concurrency 1 \ + --request-rate 1 \ + --output-file /dev/null \ + --output-details \ + >> "'"${log_dir_global}/warmup.log"'" 2>&1 + ' + log "warmup completed, waiting for TileLang compilation to settle..." + sleep 15 + log "warmup settle done" +} + +scenario_already_completed() { + local output_file="$1" + local expected="$2" + [[ -s "$output_file" ]] || return 1 + local completed + completed="$("$PYTHON" -c " +import json, sys +path = sys.argv[1] +try: + with open(path, 'r', encoding='utf-8') as f: + for line in f: + line = line.strip() + if line: + data = json.loads(line) + print(data.get('completed', 0)) + break +except Exception: + print(0) +" "$output_file")" + [[ "${completed:-0}" -ge "$expected" ]] +} + +scenario_already_processed() { + local result_root="$1" + local scenario_name="$2" + local json_path="${result_root}/results.json" + [[ -f "$json_path" ]] || return 1 + "$PYTHON" -c " +import json, sys +path, name = sys.argv[1], sys.argv[2] +try: + with open(path, 'r', encoding='utf-8') as f: + data = json.load(f) + for s in data.get('scenarios', []): + if s.get('name') == name: + if s.get('status') or s.get('metrics', {}).get('success', 0) > 0: + sys.exit(0) +except Exception: + pass +sys.exit(1) +" "$json_path" "$scenario_name" +} + +detect_oom() { + local detail_log="$1" + local server_outer_log="$2" + local pattern='CUDA out of memory|torch\.OutOfMemoryError|OutOfMemory|out of memory|OOM|RESOURCE_EXHAUSTED|Failed to allocate memory' + if grep -Eiq "$pattern" "$detail_log" "$server_outer_log" 2>/dev/null; then + return 0 + fi + return 1 +} + +start_gpu_monitor() { + local csv_path="$1" + mkdir -p "$(dirname "$csv_path")" + nvidia-smi \ + --query-gpu=timestamp,index,memory.used,memory.total,utilization.gpu \ + --format=csv \ + -l "$GPU_MEM_SAMPLE_INTERVAL_S" \ + > "$csv_path" 2>/dev/null & + echo $! +} + +stop_gpu_monitor() { + local pid="$1" + if kill -0 "$pid" 2>/dev/null; then + kill "$pid" 2>/dev/null || true + sleep 1 + kill -9 "$pid" 2>/dev/null || true + fi +} + +append_scenario_record() { + local result_root="$1" + local json_path="$result_root/results.json" + shift + local scenario_json + scenario_json="$("$PYTHON" -c " +import json, sys +pairs = [a.split('=', 1) for a in sys.argv[1:]] +d = {} +for k, v in pairs: + try: + d[k] = json.loads(v) + except json.JSONDecodeError: + d[k] = v +print(json.dumps(d, ensure_ascii=False)) +" "$@")" + PYTHON="$PYTHON" append_scenario_to_json "$json_path" "$scenario_json" +} + +record_skipped_csv() { + local csv_path="$1" + shift + # Args: key=value + local row + row="$("$PYTHON" -c " +import csv, json, sys, io +pairs = [a.split('=', 1) for a in sys.argv[1:]] +d = {} +for k, v in pairs: + try: + d[k] = json.loads(v) + except json.JSONDecodeError: + d[k] = v +buf = io.StringIO() +writer = csv.DictWriter(buf, fieldnames=['engine','tp','dp','mark','isl','osl','concurrency','status','reason','detail_log'], extrasaction='ignore') +writer.writerow(d) +print(buf.getvalue().strip()) +" "$@")" + echo "$row" >> "$csv_path" +} + +skip_remaining_scenarios() { + local result_root="$1" + local scenario_tsv="$2" + local start_index="$3" + local status="$4" + local reason="$5" + local tp="$6" + local dp="$7" + local skipped_csv="${RESULT_BASE}/${RUN_ID}/skipped_after_oom.csv" + + local i=0 + tail -n +2 "$scenario_tsv" | while IFS=$'\t' read -r mark isl osl conc num; do + if (( i < start_index )); then + i=$((i + 1)) + continue + fi + i=$((i + 1)) + local sname="c${conc}_i${isl}_o${osl}" + if scenario_already_processed "$result_root" "$sname"; then + continue + fi + append_scenario_record "$result_root" \ + "name=${sname}" \ + "config=$(jq -n --arg phase main --argjson c "$conc" --argjson i "$isl" --argjson o "$osl" --arg dataset random --argjson n "$num" '{phase: $phase, concurrency: $c, input_len: $i, output_len: $o, dataset: $dataset, num_prompts: $n}')" \ + "status=\"${status}\"" \ + "note=\"${reason}\"" + record_skipped_csv "$skipped_csv" \ + "engine=sglang" "tp=${tp}" "dp=${dp}" "mark=${mark}" "isl=${isl}" "osl=${osl}" "concurrency=${conc}" "status=${status}" "reason=${reason}" + done +} + +# --------------------------------------------------------------------------- +# Per-configuration runner +# --------------------------------------------------------------------------- + +run_parallel_config() { + local tp="$1" + local dp="$2" + local config_label="tp${tp}_dp${dp}" + local result_root="${RESULT_BASE}/${RUN_ID}/${config_label}" + local raw_dir="${result_root}/raw_outputs" + local gpu_log_dir="${result_root}/gpu_logs" + local phase_log_dir="${result_root}/logs" + mkdir -p "$raw_dir" "$gpu_log_dir" "$phase_log_dir" + + log "===== ${config_label} START =====" + + # Generate scenario list for this config. + local scenario_tsv="${result_root}/scenarios.tsv" + "$PYTHON" "${SCRIPT_DIR}/generate_scenarios.py" \ + --matrix "$MATRIX_FILE" \ + --mode "$MATRIX_MODE" \ + > "$scenario_tsv" + local total_scenarios + total_scenarios="$(tail -n +2 "$scenario_tsv" | wc -l)" + log "generated ${total_scenarios} scenarios for ${config_label}" + + # Write metadata. + ensure_result_root "$result_root" + write_metadata_json \ + "${result_root}/results.json" \ + "${EXPERIMENT_NAME}_${config_label}" \ + "$RUN_ID" \ + "$MODEL_PATH" \ + "sglang" \ + "sglang" \ + "$HARDWARE" \ + "$ACCELERATOR" \ + "$CHIP" \ + "experiments/${EXPERIMENT_NAME}/run_bench.sh" \ + "$DOCKER_IMAGE" \ + "H20 SGLang TP×DP matrix for DeepSeek-V4-Flash-DSpark" + + local server_args_str + server_args_str="$(build_server_args "$tp" "$dp")" + jq --arg tp "$tp" --arg dp "$dp" --arg cuda "$CUDA_VISIBLE_DEVICES" --arg args "$server_args_str" \ + '.config = { + "tp": ($tp | tonumber), + "dp": ($dp | tonumber), + "cuda_visible_devices": $cuda, + "backend": "sglang", + "server_start_script": "experiments/'${EXPERIMENT_NAME}'/start_sglang_dp.sh", + "server_args": $args + }' "${result_root}/results.json" > "${result_root}/results.json.tmp" && \ + mv "${result_root}/results.json.tmp" "${result_root}/results.json" + + if [[ "$DRY_RUN" == "1" ]]; then + log "DRY_RUN: would start server with args: ${server_args_str}" + local line + tail -n +2 "$scenario_tsv" | while IFS=$'\t' read -r mark isl osl conc num; do + log "DRY_RUN: ${config_label} scenario mark=${mark} c=${conc} i=${isl} o=${osl} n=${num}" + done + log "===== ${config_label} DONE (dry run) =====" + return 0 + fi + + # Initialize skipped_after_oom.csv for this run. + local skipped_csv="${RESULT_BASE}/${RUN_ID}/skipped_after_oom.csv" + if [[ ! -f "$skipped_csv" ]]; then + echo "engine,tp,dp,mark,isl,osl,concurrency,status,reason,detail_log" > "$skipped_csv" + fi + + # Start server once for this TP×DP config. + if ! start_server "$tp" "$dp"; then + log "ERROR: ${config_label} failed to start; skipping all scenarios" + skip_remaining_scenarios "$result_root" "$scenario_tsv" 0 "SKIPPED_SERVICE_START_FAILED" "service failed to start" "$tp" "$dp" + log "===== ${config_label} DONE =====" + return 0 + fi + + # Warmup with a small prompt before the first scenario. + run_warmup 1024 128 || true + + # Read scenarios into an array so we can skip remaining entries on failure. + local -a scenarios=() + while IFS= read -r line; do + scenarios+=("$line") + done < <(tail -n +2 "$scenario_tsv") + + local i mark isl osl conc num + local output_file detail_log gpu_csv sname bench_rc + for (( i = 0; i < ${#scenarios[@]}; i++ )); do + IFS=$'\t' read -r mark isl osl conc num <<< "${scenarios[$i]}" + + if [[ "$GRID_LIMIT" -gt 0 && "$i" -ge "$GRID_LIMIT" ]]; then + log "GRID_LIMIT=${GRID_LIMIT} reached; skipping remaining scenarios" + skip_remaining_scenarios "$result_root" "$scenario_tsv" "$i" "SKIPPED_GRID_LIMIT" "GRID_LIMIT reached" "$tp" "$dp" + break + fi + + sname="c${conc}_i${isl}_o${osl}" + output_file="${raw_dir}/sglang_main_${conc}_${isl}_${osl}.jsonl" + detail_log="${phase_log_dir}/sglang_${config_label}_${sname}.log" + gpu_csv="${gpu_log_dir}/gpu_mem_${conc}_${isl}_${osl}.csv" + + if scenario_already_completed "$output_file" "$num" || scenario_already_processed "$result_root" "$sname"; then + log "skipping already-processed ${config_label} scenario: ${sname}" + continue + fi + + log "running ${config_label} scenario: mark=${mark} c=${conc} i=${isl} o=${osl} n=${num}" + + local gpu_pid + gpu_pid="$(start_gpu_monitor "$gpu_csv")" + + bench_rc=0 + timeout "$SCENARIO_TIMEOUT_S" bash -c ' + run_bench_serving \ + --backend sglang \ + --host 127.0.0.1 \ + --port "'"$SGLANG_PORT"'" \ + --dataset-name random \ + --dataset-path "'"$DATASET_PATH"'" \ + --random-input-len "'"$isl"'" \ + --random-output-len "'"$osl"'" \ + --num-prompts "'"$num"'" \ + --max-concurrency "'"$conc"'" \ + --request-rate 10000 \ + --output-file "'"$output_file"'" \ + --output-details \ + > "'"$detail_log"'" 2>&1 + ' || bench_rc=$? + + stop_gpu_monitor "$gpu_pid" + + if [[ "$bench_rc" -eq 0 ]]; then + log "finished ${config_label} scenario: output=${output_file}" + append_scenario_record "$result_root" \ + "name=${sname}" \ + "config=$(jq -n --arg phase main --argjson c "$conc" --argjson i "$isl" --argjson o "$osl" --arg dataset random --argjson n "$num" '{phase: $phase, concurrency: $c, input_len: $i, output_len: $o, dataset: $dataset, num_prompts: $n}')" \ + "status=\"completed\"" \ + "note=\"benchmark finished successfully\"" + continue + fi + + # Failure handling. + if detect_oom "$detail_log" "${log_dir_global}/sglang_tp${tp}_dp${dp}.server.outer.log"; then + log "ERROR: ${config_label} scenario ${sname} triggered OOM; stopping config" + append_scenario_record "$result_root" \ + "name=${sname}" \ + "config=$(jq -n --arg phase main --argjson c "$conc" --argjson i "$isl" --argjson o "$osl" --arg dataset random --argjson n "$num" '{phase: $phase, concurrency: $c, input_len: $i, output_len: $o, dataset: $dataset, num_prompts: $n}')" \ + "status=\"OOM\"" \ + "note=\"detected CUDA out-of-memory\"" + record_skipped_csv "$skipped_csv" \ + "engine=sglang" "tp=${tp}" "dp=${dp}" "mark=${mark}" "isl=${isl}" "osl=${osl}" "concurrency=${conc}" "status=OOM" "reason=detected CUDA out-of-memory" "detail_log=${detail_log}" + stop_server "$tp" "$dp" + skip_remaining_scenarios "$result_root" "$scenario_tsv" "$((i + 1))" "SKIPPED_AFTER_OOM" "previous case OOM" "$tp" "$dp" + break + fi + + log "ERROR: ${config_label} scenario ${sname} failed (rc=${bench_rc}); see ${detail_log}" + if [[ "$mark" == "P" ]]; then + log "optional (P) scenario failed; recording as skipped and continuing" + append_scenario_record "$result_root" \ + "name=${sname}" \ + "config=$(jq -n --arg phase main --argjson c "$conc" --argjson i "$isl" --argjson o "$osl" --arg dataset random --argjson n "$num" '{phase: $phase, concurrency: $c, input_len: $i, output_len: $o, dataset: $dataset, num_prompts: $n}')" \ + "status=\"skipped_optional\"" \ + "note=\"optional scenario failed (rc=${bench_rc})\"" + record_skipped_csv "$skipped_csv" \ + "engine=sglang" "tp=${tp}" "dp=${dp}" "mark=${mark}" "isl=${isl}" "osl=${osl}" "concurrency=${conc}" "status=skipped_optional" "reason=optional scenario failed (rc=${bench_rc})" "detail_log=${detail_log}" + continue + fi + + # Mandatory scenario failed but not OOM: try to restart the server. + if restart_server "$tp" "$dp"; then + run_warmup 1024 128 || true + log "resuming ${config_label} after server restart" + continue + fi + + log "ERROR: ${config_label} server restart failed; skipping remaining scenarios" + append_scenario_record "$result_root" \ + "name=${sname}" \ + "config=$(jq -n --arg phase main --argjson c "$conc" --argjson i "$isl" --argjson o "$osl" --arg dataset random --argjson n "$num" '{phase: $phase, concurrency: $c, input_len: $i, output_len: $o, dataset: $dataset, num_prompts: $n}')" \ + "status=\"FAILED\"" \ + "note=\"scenario failed and server restart failed (rc=${bench_rc})\"" + record_skipped_csv "$skipped_csv" \ + "engine=sglang" "tp=${tp}" "dp=${dp}" "mark=${mark}" "isl=${isl}" "osl=${osl}" "concurrency=${conc}" "status=FAILED" "reason=scenario failed and server restart failed" "detail_log=${detail_log}" + skip_remaining_scenarios "$result_root" "$scenario_tsv" "$((i + 1))" "SKIPPED_RESTART_FAILED" "server restart failed" "$tp" "$dp" + break + done + + stop_server "$tp" "$dp" + + # Parse results. + log "parsing ${config_label} results" + "$PYTHON" "${SCRIPT_DIR}/../../../scripts/common/parse_backend.py" "$result_root" --backend sglang \ + >> "${phase_log_dir}/parse.log" 2>&1 || { + log "WARNING: parser failed for ${config_label}; see ${phase_log_dir}/parse.log" + } + + log "===== ${config_label} DONE =====" +} + +# --------------------------------------------------------------------------- +# Main +# --------------------------------------------------------------------------- + +# Cleanup any leftovers. +for cfg in "${PARALLEL_CONFIGS[@]}"; do + read -r tp dp <<< "$cfg" + stop_server "$tp" "$dp" +done + +# Run each parallel configuration. +for cfg in "${PARALLEL_CONFIGS[@]}"; do + read -r tp dp <<< "$cfg" + run_parallel_config "$tp" "$dp" +done + +# Generate cross-configuration comparison. +log "generating comparison report" +"$PYTHON" "${SCRIPT_DIR}/compare.py" \ + --run-root "${RESULT_BASE}/${RUN_ID}" \ + --output "${RESULT_BASE}/${RUN_ID}/comparison.md" \ + >> "${log_dir_global}/compare.log" 2>&1 || { + log "WARNING: comparison script failed; see ${log_dir_global}/compare.log" + } + +log "all results saved to ${RESULT_BASE}/${RUN_ID}" diff --git a/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/run_sglang_in_container.sh b/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/run_sglang_in_container.sh new file mode 100755 index 0000000..5bb4296 --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/run_sglang_in_container.sh @@ -0,0 +1,93 @@ +#!/usr/bin/env bash +# Run SGLang server inside the already-running benchmark container. +# Usage: run_sglang_in_container.sh +set -e + +TP="${1}" +DP="${2}" + +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +# shellcheck source=/dev/null +source "${SCRIPT_DIR}/config.env" + +RUNTIME_BASE="${RUNTIME_BASE:-${SCRIPT_DIR}/runtime}" +mkdir -p "${RUNTIME_BASE}/logs" + +PORT="${SGLANG_PORT:-30033}" +NAME="${EXPERIMENT}_sglang_container" +PID_FILE="${RUNTIME_BASE}/${EXPERIMENT}_sglang_tp${TP}_dp${DP}.pid" + +LOG="${RUNTIME_BASE}/logs/${EXPERIMENT}_sglang_in_container_tp${TP}_dp${DP}_$(date +%Y%m%d_%H%M%S).log" +rm -f "$PID_FILE" + +# Build server args. +SERVER_ARGS=( + serve + --model-path "$MODEL_PATH" + --trust-remote-code + --tp-size "$TP" + --moe-runner-backend "$MOE_RUNNER_BACKEND" + --context-length "$CONTEXT_LENGTH" + --max-running-requests "$MAX_RUNNING_REQUESTS" + --mem-fraction-static "$MEM_FRACTION_STATIC" + --host 0.0.0.0 + --port "$PORT" +) + +if [[ "$DP" -gt 1 ]]; then + SERVER_ARGS+=( + --dp-size "$DP" + ) +fi + +SERVER_ARGS_STR="${SERVER_ARGS[*]}" + +echo "=== Starting SGLang server inside container (TP=${TP}, DP=${DP}) ===" +echo "Container: $NAME" +echo "Command: sglang ${SERVER_ARGS_STR}" +echo "Log: $LOG" + +# Kill any existing sglang process inside container first. +docker exec "$NAME" pkill -9 -f "sglang serve" 2>/dev/null || true +sleep 3 + +# Start sglang serve inside the container in background. +# We use nohup so it survives after docker exec returns. +docker exec -d \ + -e CUDA_VISIBLE_DEVICES="${CUDA_VISIBLE_DEVICES}" \ + -e PYTHONUNBUFFERED=1 \ + "$NAME" \ + bash -c "nohup sglang ${SERVER_ARGS_STR} > /tmp/sglang_server.log 2>&1 &" + +# Wait for the server process to appear inside container. +sleep 2 +SERVER_PID=$(docker exec "$NAME" pgrep -f "sglang serve" | head -n 1 || true) +if [[ -z "$SERVER_PID" ]]; then + echo "ERROR: sglang server process not found inside container" + docker exec "$NAME" cat /tmp/sglang_server.log 2>/dev/null | tail -50 || true + exit 1 +fi + +echo "Server PID inside container: $SERVER_PID" +echo "$SERVER_PID" > "$PID_FILE" + +echo "Waiting for health on port ${PORT}..." +for i in $(seq 1 360); do + if curl --fail --silent --show-error --max-time 5 "http://127.0.0.1:${PORT}/health" >/dev/null 2>&1; then + echo "SGLang server is ready at http://127.0.0.1:${PORT}" + echo "Log: $LOG" + exit 0 + fi + # Check if server process is still alive. + if ! docker exec "$NAME" kill -0 "$SERVER_PID" 2>/dev/null; then + echo "ERROR: SGLang server exited early" + docker exec "$NAME" cat /tmp/sglang_server.log 2>/dev/null | tail -200 || true + exit 1 + fi + echo "Waiting... ($i/360)" + sleep 5 +done + +echo "ERROR: SGLang server not healthy after 360 retries (30 mins)" +docker exec "$NAME" cat /tmp/sglang_server.log 2>/dev/null | tail -200 || true +exit 1 diff --git a/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/start_sglang_container.sh b/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/start_sglang_container.sh new file mode 100755 index 0000000..77c30cc --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/start_sglang_container.sh @@ -0,0 +1,70 @@ +#!/usr/bin/env bash +# Start a long-running Docker container for SGLang benchmarking. +# The container stays alive (sleep infinity) so we can docker exec into it +# to run different TP×DP configurations without losing DeepGEMM JIT cache. +# +# Usage: start_sglang_container.sh +set -e + +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +# shellcheck source=/dev/null +source "${SCRIPT_DIR}/config.env" + +RUNTIME_BASE="${RUNTIME_BASE:-${SCRIPT_DIR}/runtime}" +mkdir -p "${RUNTIME_BASE}/logs" "${RUNTIME_BASE}/tmp" + +IMAGE="${DOCKER_IMAGE:-lmsysorg/sglang:latest}" +PORT="${SGLANG_PORT:-30033}" +NAME="${EXPERIMENT}_sglang_container" +PID_FILE="${RUNTIME_BASE}/${EXPERIMENT}_container.pid" + +# Persistent cache directory on host for DeepGEMM JIT kernels. +CACHE_DIR="${RUNTIME_BASE}/cache" +mkdir -p "${CACHE_DIR}/deep_gemm" "${CACHE_DIR}/tvm-ffi" + +# Clean up any stale container. +docker rm -f "$NAME" >/dev/null 2>&1 || true + +LOG="${RUNTIME_BASE}/logs/${EXPERIMENT}_container_$(date +%Y%m%d_%H%M%S).log" +rm -f "$PID_FILE" + +echo "=== Starting SGLang benchmark container ===" +echo "Image: $IMAGE" +echo "Container name: $NAME" +echo "Host port: $PORT" +echo "Cache dir: $CACHE_DIR" +echo "Log: $LOG" + +# Start a long-running container. +# We override the entrypoint to sleep infinity so the container stays alive. +docker run -d \ + --name "$NAME" \ + --gpus all \ + --ipc host \ + --shm-size 16g \ + --entrypoint /bin/bash \ + -p "${PORT}:${PORT}" \ + -v "${MODEL_PATH}:${MODEL_PATH}:ro" \ + -v "${CACHE_DIR}/deep_gemm:/root/.cache/deep_gemm" \ + -v "${CACHE_DIR}/tvm-ffi:/root/.cache/tvm-ffi" \ + -v "${RUNTIME_BASE}/tmp:/tmp" \ + -e CUDA_VISIBLE_DEVICES="${CUDA_VISIBLE_DEVICES}" \ + -e PYTHONUNBUFFERED=1 \ + "$IMAGE" \ + -c "sleep infinity" \ + > "$LOG" 2>&1 + +# Wait a moment for container to be ready. +sleep 2 + +if ! docker ps --filter "name=$NAME" --format '{{.Names}}' | grep -q "$NAME"; then + echo "ERROR: Container failed to start" + tail -50 "$LOG" + exit 1 +fi + +# Record the container ID for later use. +docker inspect -f '{{.Id}}' "$NAME" > "$PID_FILE" + +echo "Container $NAME is running" +echo "Log: $LOG" diff --git a/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/start_sglang_docker.sh b/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/start_sglang_docker.sh new file mode 100755 index 0000000..c487d4e --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/start_sglang_docker.sh @@ -0,0 +1,99 @@ +#!/usr/bin/env bash +# Start SGLang server in Docker for a given TPxDP configuration. +# Usage: start_sglang_docker.sh +# +# Uses the lmsysorg/sglang image and the same argument set as the +# bare-metal start script. The container is removed automatically on stop. +set -e + +TP="${1}" +DP="${2}" + +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +# shellcheck source=/dev/null +source "${SCRIPT_DIR}/config.env" + +RUNTIME_BASE="${RUNTIME_BASE:-${SCRIPT_DIR}/runtime}" +mkdir -p "${RUNTIME_BASE}/logs" "${RUNTIME_BASE}/tmp" + +IMAGE="${DOCKER_IMAGE:-lmsysorg/sglang:latest}" +PORT="${SGLANG_PORT:-30033}" +NAME="${EXPERIMENT}_sglang_tp${TP}_dp${DP}" +PID_FILE="${RUNTIME_BASE}/${EXPERIMENT}_sglang_tp${TP}_dp${DP}.pid" + +LOG="${RUNTIME_BASE}/logs/${EXPERIMENT}_sglang_docker_tp${TP}_dp${DP}_$(date +%Y%m%d_%H%M%S).log" +rm -f "$PID_FILE" + +# Clean up any stale container with the same name. +docker rm -f "$NAME" >/dev/null 2>&1 || true + +SERVER_ARGS=( + serve + --model-path "$MODEL_PATH" + --trust-remote-code + --tp-size "$TP" + --moe-runner-backend "$MOE_RUNNER_BACKEND" + --context-length "$CONTEXT_LENGTH" + --max-running-requests "$MAX_RUNNING_REQUESTS" + --mem-fraction-static "$MEM_FRACTION_STATIC" + --host 0.0.0.0 + --port "$PORT" +) + +if [[ "$DP" -gt 1 ]]; then + SERVER_ARGS+=( + --dp-size "$DP" + ) +fi + +SERVER_ARGS_STR="${SERVER_ARGS[*]}" + +echo "=== Starting SGLang server in Docker (TP=${TP}, DP=${DP}) ===" +echo "Image: $IMAGE" +echo "Model: $MODEL_PATH" +echo "Container name: $NAME" +echo "Host port: $PORT" +echo "Command: sglang ${SERVER_ARGS_STR}" +echo "Log: $LOG" + +# Run docker in the foreground so that killing the host process stops the +# container (the --rm flag ensures cleanup). nohup lets us background it and +# capture the host PID in the same way as the bare-metal start script. +nohup docker run --rm \ + --name "$NAME" \ + --gpus all \ + --ipc host \ + --shm-size 16g \ + --entrypoint sglang \ + -p "${PORT}:${PORT}" \ + -v "${MODEL_PATH}:${MODEL_PATH}:ro" \ + -v "${RUNTIME_BASE}/tmp:/tmp" \ + -e CUDA_VISIBLE_DEVICES="${CUDA_VISIBLE_DEVICES}" \ + -e PYTHONUNBUFFERED=1 \ + "$IMAGE" \ + "${SERVER_ARGS[@]}" \ + > "$LOG" 2>&1 & + +PID=$! +echo $PID > "$PID_FILE" +echo "PID: $PID" +echo "Waiting for health on port ${PORT}..." + +for i in $(seq 1 240); do + if curl --fail --silent --show-error --max-time 5 "http://127.0.0.1:${PORT}/health" >/dev/null 2>&1; then + echo "SGLang server is ready at http://127.0.0.1:${PORT}" + echo "Log: $LOG" + exit 0 + fi + if ! kill -0 $PID 2>/dev/null; then + echo "ERROR: Docker SGLang server exited early" + tail -200 "$LOG" + exit 1 + fi + echo "Waiting... ($i/240)" + sleep 5 +done + +echo "ERROR: Docker SGLang server not healthy after 240 retries" +tail -200 "$LOG" +exit 1 diff --git a/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/start_sglang_dp.sh b/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/start_sglang_dp.sh new file mode 100755 index 0000000..230bf88 --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_sglang_tp_dp_matrix/start_sglang_dp.sh @@ -0,0 +1,86 @@ +#!/usr/bin/env bash +# Start SGLang server for a given TP×DP configuration. +# Usage: start_sglang_dp.sh +# +# By default this delegates to the Docker start script because the experiment +# is intended to run SGLang inside a container. Set USE_DOCKER=0 to use the +# local VENV_CLIENT environment instead. +set -e + +TP="${1}" +DP="${2}" + +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +# shellcheck source=/dev/null +source "${SCRIPT_DIR}/config.env" + +if [[ "${USE_DOCKER:-1}" == "1" ]]; then + exec "${SCRIPT_DIR}/start_sglang_docker.sh" "$@" +fi + +RUNTIME_BASE="${RUNTIME_BASE:-${SCRIPT_DIR}/runtime}" +mkdir -p "${RUNTIME_BASE}/logs" "${RUNTIME_BASE}/tmp" + +VENV="${VENV_CLIENT}" +export PATH="$VENV/bin:$PATH" +export PYTHONUNBUFFERED=1 +export TMPDIR="${RUNTIME_BASE}/tmp" +export CUDA_VISIBLE_DEVICES="${CUDA_VISIBLE_DEVICES}" + +LOG="${RUNTIME_BASE}/logs/${EXPERIMENT}_sglang_tp${TP}_dp${DP}_$(date +%Y%m%d_%H%M%S).log" +PID_FILE="${RUNTIME_BASE}/${EXPERIMENT}_sglang_tp${TP}_dp${DP}.pid" + +rm -f "$PID_FILE" + +SERVER_ARGS=( + sglang serve + --model-path "$MODEL_PATH" + --trust-remote-code + --tp-size "$TP" + --moe-runner-backend "$MOE_RUNNER_BACKEND" + --context-length "$CONTEXT_LENGTH" + --max-running-requests "$MAX_RUNNING_REQUESTS" + --mem-fraction-static "$MEM_FRACTION_STATIC" + --host 0.0.0.0 + --port "$SGLANG_PORT" +) + +if [[ "$DP" -gt 1 ]]; then + SERVER_ARGS+=( + --dp-size "$DP" + ) +fi + +SERVER_ARGS_STR="${SERVER_ARGS[*]}" + +echo "=== Starting SGLang server (TP=${TP}, DP=${DP}) ===" +echo "Model: $MODEL_PATH" +echo "Port: $SGLANG_PORT" +echo "Command: $SERVER_ARGS_STR" +echo "Log: $LOG" + +nohup "${SERVER_ARGS[@]}" > "$LOG" 2>&1 & + +PID=$! +echo $PID > "$PID_FILE" +echo "PID: $PID" +echo "Waiting for health on port ${SGLANG_PORT}..." + +for i in $(seq 1 240); do + if curl --fail --silent --show-error --max-time 5 "http://127.0.0.1:${SGLANG_PORT}/health" >/dev/null 2>&1; then + echo "SGLang server is ready at http://127.0.0.1:${SGLANG_PORT}" + echo "Log: $LOG" + exit 0 + fi + if ! kill -0 $PID 2>/dev/null; then + echo "ERROR: SGLang server exited early" + tail -200 "$LOG" + exit 1 + fi + echo "Waiting... ($i/240)" + sleep 5 +done + +echo "ERROR: SGLang server not healthy after 240 retries" +tail -200 "$LOG" +exit 1 diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/README.md b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/README.md new file mode 100644 index 0000000..9bc6fb1 --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/README.md @@ -0,0 +1,65 @@ +# DSV4 DSpark H20 vLLM TP×DP Matrix Benchmark + +NVIDIA H20 + vLLM (Docker) + `DeepSeek-V4-Flash-DSpark` TP×DP matrix benchmark. + +Adapted from `experiments/h20/dsv4_h20_vllm_tp_dp_matrix`, with the model swapped +to `/data1/hf_models/DeepSeek-V4-Flash-DSpark` and DSpark speculative decoding +enabled (aligned with `experiments/h200/dsv4_h200_vllm_dspark_vs_default`): + +- `--spec-method dspark --spec-model --spec-tokens 5` +- `--tokenizer-mode deepseek_v4 --reasoning-parser deepseek_v4` +- `--no-disable-hybrid-kv-cache-manager --disable-uvicorn-access-log` + +All other parameters (KV cache fp8, block size 256, max-model-len 1M, +max-num-seqs 128, ISL/OSL matrix, concurrency rules) are identical to the +non-DSpark H20 vLLM matrix experiment. + +## Requirements + +The serving environment must include a vLLM build with `dspark` speculative +decoding support (the stock `vllm/vllm-openai:latest` image may not). Either: + +- point `DOCKER_IMAGE` to an image with dspark support, or +- set `USE_DOCKER=0` and `VENV_VLLM` to a native env with dspark support. + +## Quick Start + +```bash +# Dry run: print server args and scenario plan only +DRY_RUN=1 bash experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/run_bench.sh + +# Full TP×DP matrix run +bash experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/run_bench.sh + +# Adaptive concurrency search (+16 per step, aligned with +# dsv4_h20_vllm_tp_dp_matrix/run_adaptive_concurrency_add16.sh) +bash experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/run_adaptive_concurrency_add16.sh +``` + +Results land in `experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/results//`. + +## Configuration + +Edit `config.env` or override via environment variables: + +```bash +MODEL_PATH=/data1/hf_models/DeepSeek-V4-Flash-DSpark \ +VLLM_PORT=30032 \ +SPEC_TOKENS=5 \ +bash experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/run_bench.sh +``` + +Cold-start note: the DSpark draft model compiles ~140 TileLang kernels plus +CUDA graphs on first launch, which exceeds vLLM's default 600s engine-ready +timeout. `config.env` therefore sets `VLLM_ENGINE_READY_TIMEOUT_S=3600` and +`HEALTH_CHECK_RETRIES=720` (60min), and `start_vllm_docker.sh` persists the +TileLang/DeepGEMM JIT caches under `runtime/cache/` so later TP×DP configs and +reruns start much faster. + +## Files + +Same layout as `dsv4_h20_vllm_tp_dp_matrix`; see that experiment for details. + +## Platform + +This experiment targets `platforms/nvidia_h20.env`. diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_config.env b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_config.env new file mode 100644 index 0000000..e35c41f --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_config.env @@ -0,0 +1,55 @@ +# Adaptive concurrency search settings. +# +# For each fixed (TP, DP, ISL, OSL), probe: +# C = start, start * multiplier, ... up to max +# and stop after Total TPS has less than TPS_MIN_GAIN_PCT meaningful growth for +# PLATEAU_PATIENCE consecutive points. + +SEARCH_START_CONCURRENCY="${SEARCH_START_CONCURRENCY:-1}" +SEARCH_MAX_CONCURRENCY="${SEARCH_MAX_CONCURRENCY:-512}" +SEARCH_MULTIPLIER="${SEARCH_MULTIPLIER:-2}" +NUM_PROMPTS_MULTIPLIER="${NUM_PROMPTS_MULTIPLIER:-5}" + +# A gain below 2% is treated as throughput saturation. Two consecutive +# low-gain points prevent one noisy measurement from stopping the search. +TPS_MIN_GAIN_PCT="${TPS_MIN_GAIN_PCT:-2.0}" +PLATEAU_PATIENCE="${PLATEAU_PATIENCE:-2}" + +# TTFT SLO early-stop settings. +# When ttft_p95_ms exceeds TTFT_SLO_MS, stop searching the current (ISL, OSL) +# shape and move on to the next scenario. +TTFT_SLO_MS="${TTFT_SLO_MS:-4000}" +ENABLE_TTFT_SLO_STOP="${ENABLE_TTFT_SLO_STOP:-1}" + +# Keep the same random workload semantics as the fixed matrix baseline. +# DATASET_PATH must contain at least SEARCH_MAX_CONCURRENCY times +# NUM_PROMPTS_MULTIPLIER valid two-turn conversations. Set this explicitly to +# random-ids to use generated token IDs without a ShareGPT seed dataset. +BENCH_DATASET_NAME="${BENCH_DATASET_NAME:-random}" +# SGLang interprets 0.0 as Uniform[1, requested_len]. Use 1.0 for fixed +# ISL/OSL points; lower values intentionally benchmark a length distribution. +RANDOM_RANGE_RATIO="${RANDOM_RANGE_RATIO:-1.0}" +# Before each measured point, warm up with the same concurrency so lazy kernel +# compilation and CUDA graph capture are excluded from TTFT/TPS. 0 means no +# cap; set a positive cap only when very high-concurrency warmup is impractical. +BENCH_WARMUP_MAX_REQUESTS="${BENCH_WARMUP_MAX_REQUESTS:-0}" + +# Reject a point if the completed request count or actual token lengths do not +# match the requested workload. +INPUT_LENGTH_TOLERANCE_PCT="${INPUT_LENGTH_TOLERANCE_PCT:-5.0}" +OUTPUT_LENGTH_TOLERANCE_PCT="${OUTPUT_LENGTH_TOLERANCE_PCT:-10.0}" + +MAX_POINT_RETRIES="${MAX_POINT_RETRIES:-1}" +SERVER_RESTART_COOLDOWN_S="${SERVER_RESTART_COOLDOWN_S:-10}" +SCENARIO_TIMEOUT_S="${SCENARIO_TIMEOUT_S:-1800}" +GPU_MEM_SAMPLE_INTERVAL_S="${GPU_MEM_SAMPLE_INTERVAL_S:-1}" + +# Optional space-separated filters, useful for smoke tests: +# TP_LIST="8" ISL_LIST="1024" OSL_LIST="128" +TP_LIST="${TP_LIST:-}" +ISL_LIST="${ISL_LIST:-}" +OSL_LIST="${OSL_LIST:-}" + +DRY_RUN="${DRY_RUN:-0}" +# Counts ISL/OSL shapes per TP/DP config, not individual concurrency probes. +GRID_LIMIT="${GRID_LIMIT:-0}" diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/adaptive_points.jsonl b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/adaptive_points.jsonl new file mode 100644 index 0000000..fcc15cc --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/adaptive_points.jsonl @@ -0,0 +1,372 @@ +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":30.566418703005183,"request_tps":2.6172513298764266,"input_tps":2680.065361793461,"output_tps":335.0081702241826,"total_tps":3015.0735320176436,"mean_input_tokens":1024.0,"mean_output_tokens":128.0,"ttft_p50_ms":959.9164439714514,"ttft_p95_ms":10211.646821975592,"ttft_p99_ms":10221.430452906643,"tpot_p50_ms":23.15357961420586,"tpot_p95_ms":63.818165101088006,"tpot_p99_ms":83.51021226904781,"e2e_p50_ms":4232.26421099389,"e2e_p95_ms":11185.429745013242,"e2e_p99_ms":13795.313537065489,"itl_p50_ms":36.179293994791806,"itl_p95_ms":334.5014255028218,"itl_p99_ms":2741.277672216529,"validation_errors":[],"timestamp":"2026-07-18T05:27:12+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":128,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c16_i1024_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c16_i1024_o128_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":34.237122531980276,"request_tps":1.1683224827856582,"input_tps":1196.362222372514,"output_tps":149.54527779656425,"total_tps":1345.9075001690783,"mean_input_tokens":1024.0,"mean_output_tokens":128.0,"ttft_p50_ms":409.91352949640714,"ttft_p95_ms":26172.55401664297,"ttft_p99_ms":26383.220855958643,"tpot_p50_ms":8.740242728303503,"tpot_p95_ms":17.36125378687515,"tpot_p99_ms":142.38196347630205,"e2e_p50_ms":1720.1742354955059,"e2e_p95_ms":26878.392814044488,"e2e_p99_ms":27776.067789322697,"itl_p50_ms":21.412361500551924,"itl_p95_ms":259.5009877870325,"itl_p99_ms":280.53784487128723,"validation_errors":[],"timestamp":"2026-07-18T05:28:26+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":128,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c8_i1024_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c8_i1024_o128_a1.log"} +{"status":"COMPLETED","completed":5,"failed":0,"duration_s":2.64835100795608,"request_tps":1.8879672615069456,"input_tps":1933.2784757831123,"output_tps":241.65980947288904,"total_tps":2174.9382852560016,"mean_input_tokens":1024.0,"mean_output_tokens":128.0,"ttft_p50_ms":253.89999197795987,"ttft_p95_ms":270.49242419889197,"ttft_p99_ms":273.2291704392992,"tpot_p50_ms":2.5464493857410657,"tpot_p95_ms":2.996797603371692,"tpot_p99_ms":3.0723557161445925,"e2e_p50_ms":555.0004449905828,"e2e_p95_ms":601.2633538106456,"e2e_p99_ms":605.4744715755805,"itl_p50_ms":14.328418008517474,"itl_p95_ms":16.131273994687945,"itl_p99_ms":16.75948388176039,"validation_errors":[],"timestamp":"2026-07-18T05:29:14+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":128,"concurrency":1,"num_prompts":5,"warmup_requests":1,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c1_i1024_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c1_i1024_o128_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":23.589514082006644,"request_tps":3.391337342595859,"input_tps":3472.7294388181595,"output_tps":868.1823597045399,"total_tps":4340.911798522699,"mean_input_tokens":1024.0,"mean_output_tokens":256.0,"ttft_p50_ms":530.8994324877858,"ttft_p95_ms":896.4784298674203,"ttft_p99_ms":950.9289838862605,"tpot_p50_ms":15.448257460843259,"tpot_p95_ms":23.906393568099965,"tpot_p99_ms":27.842136794662377,"e2e_p50_ms":4574.748572485987,"e2e_p95_ms":6748.848497189463,"e2e_p99_ms":7565.012178404713,"itl_p50_ms":86.06371146743186,"itl_p95_ms":246.92099939857144,"itl_p99_ms":298.4649693209212,"validation_errors":[],"timestamp":"2026-07-18T05:30:14+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":256,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c16_i1024_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c16_i1024_o256_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":33.029187945008744,"request_tps":4.844200234846483,"input_tps":4960.461040482799,"output_tps":1240.1152601206998,"total_tps":6200.576300603499,"mean_input_tokens":1024.0,"mean_output_tokens":256.0,"ttft_p50_ms":727.2113744984381,"ttft_p95_ms":1322.7172346552436,"ttft_p99_ms":3686.448223036714,"tpot_p50_ms":23.105563435306337,"tpot_p95_ms":35.984704837639015,"tpot_p99_ms":45.960957976631065,"e2e_p50_ms":6515.264699526597,"e2e_p95_ms":9931.73770039866,"e2e_p99_ms":13126.649928535915,"itl_p50_ms":86.96807301021181,"itl_p95_ms":270.7711102964822,"itl_p99_ms":358.96943138330244,"validation_errors":[],"timestamp":"2026-07-18T05:31:37+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":256,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":42.840412,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c32_i1024_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c32_i1024_o256_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":39.050729812995996,"request_tps":6.1458518483341775,"input_tps":6293.352292694198,"output_tps":1573.3380731735494,"total_tps":7866.690365867747,"mean_input_tokens":1024.0,"mean_output_tokens":256.0,"ttft_p50_ms":813.204855483491,"ttft_p95_ms":1531.6495871258667,"ttft_p99_ms":1581.8664682656527,"tpot_p50_ms":24.80585620574215,"tpot_p95_ms":36.980264257712676,"tpot_p99_ms":54.05038318965884,"e2e_p50_ms":7176.9718460273,"e2e_p95_ms":10451.617936565888,"e2e_p99_ms":14579.444315505094,"itl_p50_ms":95.25326953735203,"itl_p95_ms":309.6233890100848,"itl_p99_ms":416.1498998902969,"validation_errors":[],"timestamp":"2026-07-18T05:33:01+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":256,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":26.87031,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c48_i1024_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c48_i1024_o256_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":37.36515981599223,"request_tps":8.56412769477947,"input_tps":8769.666759454178,"output_tps":2192.4166898635444,"total_tps":10962.08344931772,"mean_input_tokens":1024.0,"mean_output_tokens":256.0,"ttft_p50_ms":768.3787049900275,"ttft_p95_ms":1194.1611677815702,"ttft_p99_ms":1474.5633216260467,"tpot_p50_ms":24.9970277608144,"tpot_p95_ms":36.84377160234899,"tpot_p99_ms":50.11866441557148,"e2e_p50_ms":7235.340561543126,"e2e_p95_ms":10198.030453515823,"e2e_p99_ms":13563.198145279895,"itl_p50_ms":87.91903400560841,"itl_p95_ms":344.08447578898625,"itl_p99_ms":419.20184464310216,"validation_errors":[],"timestamp":"2026-07-18T05:34:18+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":256,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":39.348099,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c64_i1024_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c64_i1024_o256_a1.log"} +{"status":"COMPLETED","completed":400,"failed":0,"duration_s":49.13685654097935,"request_tps":8.140528885204661,"input_tps":8335.901578449573,"output_tps":2083.9753946123933,"total_tps":10419.876973061966,"mean_input_tokens":1024.0,"mean_output_tokens":256.0,"ttft_p50_ms":956.9711624935735,"ttft_p95_ms":1730.0367524847388,"ttft_p99_ms":8108.684035992482,"tpot_p50_ms":29.812003821636747,"tpot_p95_ms":59.761807406743436,"tpot_p99_ms":73.97714049115265,"e2e_p50_ms":8377.014341036556,"e2e_p95_ms":16540.880043921057,"e2e_p99_ms":20032.245023460127,"itl_p50_ms":89.94270299444906,"itl_p95_ms":372.49292572960235,"itl_p99_ms":506.8596551055089,"validation_errors":[],"timestamp":"2026-07-18T05:35:49+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":256,"concurrency":80,"num_prompts":400,"warmup_requests":80,"attempt":1,"gain_pct":-4.946199,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c80_i1024_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c80_i1024_o256_a1.log"} +{"status":"COMPLETED","completed":480,"failed":0,"duration_s":43.67383934103418,"request_tps":10.990561105742112,"input_tps":11254.334572279922,"output_tps":2813.5836430699806,"total_tps":14067.918215349904,"mean_input_tokens":1024.0,"mean_output_tokens":256.0,"ttft_p50_ms":905.239449988585,"ttft_p95_ms":2128.1592924293363,"ttft_p99_ms":2152.4694501888007,"tpot_p50_ms":27.66884238637217,"tpot_p95_ms":43.50117243258006,"tpot_p99_ms":68.84798307043917,"e2e_p50_ms":8033.508665015688,"e2e_p95_ms":12113.105959646055,"e2e_p99_ms":18462.63756583619,"itl_p50_ms":90.57190350722522,"itl_p95_ms":376.64349344559014,"itl_p99_ms":547.2668156289727,"validation_errors":[],"timestamp":"2026-07-18T05:37:18+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":256,"concurrency":96,"num_prompts":480,"warmup_requests":96,"attempt":1,"gain_pct":35.010406,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c96_i1024_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c96_i1024_o256_a1.log"} +{"status":"COMPLETED","completed":560,"failed":0,"duration_s":49.34996271197451,"request_tps":11.347526304495442,"input_tps":11619.866935803333,"output_tps":2904.9667339508333,"total_tps":14524.833669754165,"mean_input_tokens":1024.0,"mean_output_tokens":256.0,"ttft_p50_ms":1052.2747474897187,"ttft_p95_ms":2264.693084708415,"ttft_p99_ms":2288.8300782867004,"tpot_p50_ms":32.37125597638535,"tpot_p95_ms":51.76582108642084,"tpot_p99_ms":69.47945872291821,"e2e_p50_ms":9160.196762997657,"e2e_p95_ms":14225.293244459315,"e2e_p99_ms":18826.220967948902,"itl_p50_ms":95.5993719981052,"itl_p95_ms":401.2242454919033,"itl_p99_ms":524.2278133227956,"validation_errors":[],"timestamp":"2026-07-18T05:38:54+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":256,"concurrency":112,"num_prompts":560,"warmup_requests":112,"attempt":1,"gain_pct":3.247925,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c112_i1024_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c112_i1024_o256_a1.log"} +{"status":"COMPLETED","completed":640,"failed":0,"duration_s":47.36701444501523,"request_tps":13.511512336141164,"input_tps":13835.788632208552,"output_tps":3458.947158052138,"total_tps":17294.73579026069,"mean_input_tokens":1024.0,"mean_output_tokens":256.0,"ttft_p50_ms":998.561324988259,"ttft_p95_ms":2146.6309593524784,"ttft_p99_ms":2166.712617657613,"tpot_p50_ms":29.82348182339075,"tpot_p95_ms":50.81173647038738,"tpot_p99_ms":69.93263897376237,"e2e_p50_ms":8446.147489972645,"e2e_p95_ms":13834.740497387244,"e2e_p99_ms":18607.326975401375,"itl_p50_ms":97.43078000610694,"itl_p95_ms":389.2966297426028,"itl_p99_ms":488.5137729259442,"validation_errors":[],"timestamp":"2026-07-18T05:40:20+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":256,"concurrency":128,"num_prompts":640,"warmup_requests":128,"attempt":1,"gain_pct":19.070112,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c128_i1024_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c128_i1024_o256_a1.log"} +{"status":"COMPLETED","completed":720,"failed":0,"duration_s":49.77469638799084,"request_tps":14.4651811512348,"input_tps":14812.345498864435,"output_tps":3703.086374716109,"total_tps":18515.431873580543,"mean_input_tokens":1024.0,"mean_output_tokens":256.0,"ttft_p50_ms":1052.1761205163784,"ttft_p95_ms":2265.1621726952726,"ttft_p99_ms":2295.2592057688157,"tpot_p50_ms":32.66415426875099,"tpot_p95_ms":51.398989754585166,"tpot_p99_ms":69.14093440828618,"e2e_p50_ms":9519.265444978373,"e2e_p95_ms":14105.641560244836,"e2e_p99_ms":18313.39051707356,"itl_p50_ms":95.53958452306688,"itl_p95_ms":433.7245226430238,"itl_p99_ms":559.7135357104708,"validation_errors":[],"timestamp":"2026-07-18T05:41:52+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":256,"concurrency":144,"num_prompts":720,"warmup_requests":144,"attempt":1,"gain_pct":7.058194,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c144_i1024_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c144_i1024_o256_a1.log"} +{"status":"COMPLETED","completed":800,"failed":0,"duration_s":51.57363652798813,"request_tps":15.511801258494806,"input_tps":15884.084488698682,"output_tps":3971.0211221746704,"total_tps":19855.105610873354,"mean_input_tokens":1024.0,"mean_output_tokens":256.0,"ttft_p50_ms":1036.3968419842422,"ttft_p95_ms":2153.5759484453592,"ttft_p99_ms":2502.420874292729,"tpot_p50_ms":32.40303463923434,"tpot_p95_ms":54.85705963365604,"tpot_p99_ms":75.80160241130758,"e2e_p50_ms":9245.01782952575,"e2e_p95_ms":15107.203041770845,"e2e_p99_ms":20408.52235518105,"itl_p50_ms":136.55203700182028,"itl_p95_ms":430.3711592510808,"itl_p99_ms":530.0523744896054,"validation_errors":[],"timestamp":"2026-07-18T05:43:30+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":256,"concurrency":160,"num_prompts":800,"warmup_requests":160,"attempt":1,"gain_pct":7.235444,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c160_i1024_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c160_i1024_o256_a1.log"} +{"status":"COMPLETED","completed":880,"failed":0,"duration_s":54.938273189007305,"request_tps":16.017977066233687,"input_tps":16402.408515823296,"output_tps":4100.602128955824,"total_tps":20503.01064477912,"mean_input_tokens":1024.0,"mean_output_tokens":256.0,"ttft_p50_ms":1083.181241498096,"ttft_p95_ms":2276.9330487237307,"ttft_p99_ms":2747.1301242057234,"tpot_p50_ms":36.216354258723705,"tpot_p95_ms":55.81738806725707,"tpot_p99_ms":81.29555275548461,"e2e_p50_ms":10204.111671482679,"e2e_p95_ms":15277.817861325457,"e2e_p99_ms":21721.36293677963,"itl_p50_ms":140.06681850878522,"itl_p95_ms":452.24884372146334,"itl_p99_ms":559.505116898799,"validation_errors":[],"timestamp":"2026-07-18T05:45:06+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":256,"concurrency":176,"num_prompts":880,"warmup_requests":176,"attempt":1,"gain_pct":3.263166,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c176_i1024_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c176_i1024_o256_a1.log"} +{"status":"COMPLETED","completed":960,"failed":0,"duration_s":59.27424857800361,"request_tps":16.19590333121914,"input_tps":16584.605011168398,"output_tps":4146.1512527920995,"total_tps":20730.7562639605,"mean_input_tokens":1024.0,"mean_output_tokens":256.0,"ttft_p50_ms":1123.376781004481,"ttft_p95_ms":2159.3626584886806,"ttft_p99_ms":2852.471910266904,"tpot_p50_ms":39.31914373328362,"tpot_p95_ms":62.095327768474775,"tpot_p99_ms":84.60324621805003,"e2e_p50_ms":11156.231121509336,"e2e_p95_ms":16980.309207062233,"e2e_p99_ms":22851.697458958362,"itl_p50_ms":208.46877503208816,"itl_p95_ms":462.8467032453045,"itl_p99_ms":599.8108746134674,"validation_errors":[],"timestamp":"2026-07-18T05:46:54+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":256,"concurrency":192,"num_prompts":960,"warmup_requests":192,"attempt":1,"gain_pct":1.110791,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c192_i1024_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c192_i1024_o256_a1.log"} +{"status":"COMPLETED","completed":1040,"failed":0,"duration_s":62.40055602800567,"request_tps":16.66651815623635,"input_tps":17066.514591986022,"output_tps":4266.628647996506,"total_tps":21333.143239982528,"mean_input_tokens":1024.0,"mean_output_tokens":256.0,"ttft_p50_ms":1189.0783600101713,"ttft_p95_ms":3273.2770653325133,"ttft_p99_ms":3317.224576312583,"tpot_p50_ms":41.42505690197497,"tpot_p95_ms":62.82809296663959,"tpot_p99_ms":88.90650631534164,"e2e_p50_ms":11732.559082476655,"e2e_p95_ms":17044.6823761682,"e2e_p99_ms":23642.280080002318,"itl_p50_ms":220.03998199943453,"itl_p95_ms":471.2953300040681,"itl_p99_ms":669.0468762011732,"validation_errors":[],"timestamp":"2026-07-18T05:48:46+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":256,"concurrency":208,"num_prompts":1040,"warmup_requests":208,"attempt":1,"gain_pct":2.905765,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c208_i1024_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c208_i1024_o256_a1.log"} +{"status":"COMPLETED","completed":1120,"failed":0,"duration_s":62.96526560204802,"request_tps":17.787584778544485,"input_tps":18214.486813229552,"output_tps":4553.621703307388,"total_tps":22768.10851653694,"mean_input_tokens":1024.0,"mean_output_tokens":256.0,"ttft_p50_ms":1205.0186405249406,"ttft_p95_ms":3440.3176461928524,"ttft_p99_ms":3479.927466413937,"tpot_p50_ms":41.369188715722046,"tpot_p95_ms":63.71492860101474,"tpot_p99_ms":90.96289304844511,"e2e_p50_ms":11832.957868493395,"e2e_p95_ms":17278.333212801954,"e2e_p99_ms":24163.90890898066,"itl_p50_ms":216.2210899987258,"itl_p95_ms":525.7202670327388,"itl_p99_ms":662.3267729883082,"validation_errors":[],"timestamp":"2026-07-18T05:50:34+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":256,"concurrency":224,"num_prompts":1120,"warmup_requests":224,"attempt":1,"gain_pct":6.72646,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c224_i1024_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c224_i1024_o256_a1.log"} +{"status":"COMPLETED","completed":1200,"failed":0,"duration_s":67.2982997620129,"request_tps":17.831059688633474,"input_tps":18259.005121160677,"output_tps":4564.751280290169,"total_tps":22823.756401450846,"mean_input_tokens":1024.0,"mean_output_tokens":256.0,"ttft_p50_ms":1397.5845855020452,"ttft_p95_ms":3582.803599725594,"ttft_p99_ms":4388.67963450728,"tpot_p50_ms":43.772825125522694,"tpot_p95_ms":66.2276299264597,"tpot_p99_ms":92.8809915193763,"e2e_p50_ms":12601.688674476463,"e2e_p95_ms":18451.36761935719,"e2e_p99_ms":24939.69097335066,"itl_p50_ms":212.10296801291406,"itl_p95_ms":567.5752804992949,"itl_p99_ms":841.2334891379579,"validation_errors":[],"timestamp":"2026-07-18T05:52:30+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":256,"concurrency":240,"num_prompts":1200,"warmup_requests":240,"attempt":1,"gain_pct":0.244412,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c240_i1024_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c240_i1024_o256_a1.log"} +{"status":"COMPLETED","completed":1280,"failed":0,"duration_s":73.55571834102739,"request_tps":17.40177417703296,"input_tps":17819.41675728175,"output_tps":4454.854189320437,"total_tps":22274.270946602188,"mean_input_tokens":1024.0,"mean_output_tokens":256.0,"ttft_p50_ms":1364.753422967624,"ttft_p95_ms":4958.0106256617,"ttft_p99_ms":5567.213252282236,"tpot_p50_ms":48.39243760786713,"tpot_p95_ms":71.43578725530281,"tpot_p99_ms":98.74257584787934,"e2e_p50_ms":13681.47547749686,"e2e_p95_ms":19713.627809853642,"e2e_p99_ms":27417.63783195871,"itl_p50_ms":254.84758251695894,"itl_p95_ms":571.9881741999416,"itl_p99_ms":979.0615296835317,"validation_errors":[],"timestamp":"2026-07-18T05:54:33+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":256,"concurrency":256,"num_prompts":1280,"warmup_requests":256,"attempt":1,"gain_pct":-2.407515,"plateau_streak":2,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c256_i1024_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c256_i1024_o256_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":44.074823962000664,"request_tps":1.8150951679120129,"input_tps":1858.6574519419012,"output_tps":929.3287259709506,"total_tps":2787.9861779128514,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":410.0118414789904,"ttft_p95_ms":616.3779693742979,"ttft_p99_ms":706.3737252244026,"tpot_p50_ms":16.18833231896667,"tpot_p95_ms":23.222884791327957,"tpot_p99_ms":26.100657191113854,"e2e_p50_ms":8560.402222967241,"e2e_p95_ms":12373.914034108748,"e2e_p99_ms":13752.522494391878,"itl_p50_ms":87.44017398566939,"itl_p95_ms":220.33475612697657,"itl_p99_ms":254.18294373492245,"validation_errors":[],"timestamp":"2026-07-18T05:56:00+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":512,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c16_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c16_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":38.65939177700784,"request_tps":4.138709706632215,"input_tps":4238.038739591389,"output_tps":2119.0193697956943,"total_tps":6357.058109387083,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":447.67517800210044,"ttft_p95_ms":790.4462870006682,"ttft_p99_ms":833.443894109223,"tpot_p50_ms":14.47137067026783,"tpot_p95_ms":19.99165176615231,"tpot_p99_ms":26.931548822644288,"e2e_p50_ms":7846.653045504354,"e2e_p95_ms":10671.020146476803,"e2e_p99_ms":14379.890875712152,"itl_p50_ms":82.29589049005881,"itl_p95_ms":230.60692503349853,"itl_p99_ms":255.95839274697934,"validation_errors":[],"timestamp":"2026-07-18T05:57:19+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":512,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":128.016127,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c32_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c32_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":51.93111940997187,"request_tps":4.621506386282807,"input_tps":4732.422539553594,"output_tps":2366.211269776797,"total_tps":7098.63380933039,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":557.031554490095,"ttft_p95_ms":863.0683689174474,"ttft_p99_ms":1128.0856553203193,"tpot_p50_ms":17.768167567447577,"tpot_p95_ms":25.74457378146499,"tpot_p99_ms":34.27725556816284,"e2e_p50_ms":9555.628300528042,"e2e_p95_ms":13750.126729664027,"e2e_p99_ms":18038.809328731724,"itl_p50_ms":85.784294991754,"itl_p95_ms":245.7967065507546,"itl_p99_ms":260.55232431506744,"validation_errors":[],"timestamp":"2026-07-18T05:58:53+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":512,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":11.665391,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c48_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c48_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":48.688340422988404,"request_tps":6.572415432934138,"input_tps":6730.153403324557,"output_tps":3365.0767016622785,"total_tps":10095.230104986835,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":552.5115790078416,"ttft_p95_ms":1314.9929781415267,"ttft_p99_ms":1357.4799077986972,"tpot_p50_ms":17.485559259248813,"tpot_p95_ms":25.339783645828927,"tpot_p99_ms":33.67193682901693,"e2e_p50_ms":9497.276944515761,"e2e_p95_ms":13358.827306676543,"e2e_p99_ms":17643.290258415513,"itl_p50_ms":79.62858199607581,"itl_p95_ms":243.28022862318903,"itl_p99_ms":271.3882778445259,"validation_errors":[],"timestamp":"2026-07-18T06:00:25+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":512,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":42.213704,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c64_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c64_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":400,"failed":0,"duration_s":57.05530345294392,"request_tps":7.010741785466061,"input_tps":7178.999588317247,"output_tps":3589.4997941586234,"total_tps":10768.499382475871,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":678.2892069895752,"ttft_p95_ms":1505.1418148330413,"ttft_p99_ms":1517.1429479436483,"tpot_p50_ms":20.383543070460853,"tpot_p95_ms":33.784646433440855,"tpot_p99_ms":44.31178373318126,"e2e_p50_ms":11045.338449504925,"e2e_p95_ms":17939.439023521816,"e2e_p99_ms":23197.962124274916,"itl_p50_ms":85.85569600109011,"itl_p95_ms":269.93017821805546,"itl_p99_ms":295.20422559464066,"validation_errors":[],"timestamp":"2026-07-18T06:02:07+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":512,"concurrency":80,"num_prompts":400,"warmup_requests":80,"attempt":1,"gain_pct":6.669182,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c80_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c80_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":480,"failed":0,"duration_s":64.8196835090057,"request_tps":7.4051580324873285,"input_tps":7582.881825267024,"output_tps":3791.440912633512,"total_tps":11374.322737900537,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":720.2231799892616,"ttft_p95_ms":1780.3673721384257,"ttft_p99_ms":1808.122864511679,"tpot_p50_ms":22.556084386515476,"tpot_p95_ms":32.65474251583201,"tpot_p99_ms":46.05874615321924,"e2e_p50_ms":12280.233262950787,"e2e_p95_ms":17531.4878147532,"e2e_p99_ms":24411.42290716583,"itl_p50_ms":91.65590000338852,"itl_p95_ms":273.7472573673585,"itl_p99_ms":316.2743381469045,"validation_errors":[],"timestamp":"2026-07-18T06:03:57+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":512,"concurrency":96,"num_prompts":480,"warmup_requests":96,"attempt":1,"gain_pct":5.625885,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c96_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c96_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":560,"failed":0,"duration_s":64.42355161497835,"request_tps":8.69247326423092,"input_tps":8901.092622572462,"output_tps":4450.546311286231,"total_tps":13351.638933858692,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":722.9088099848013,"ttft_p95_ms":1936.134582161321,"ttft_p99_ms":1966.849296436994,"tpot_p50_ms":22.656001746581612,"tpot_p95_ms":34.01750318228526,"tpot_p99_ms":45.83924455262574,"e2e_p50_ms":12290.569957491243,"e2e_p95_ms":17903.125924358013,"e2e_p99_ms":24173.57677194173,"itl_p50_ms":84.23292401130311,"itl_p95_ms":264.3887641024776,"itl_p99_ms":320.45294351293694,"validation_errors":[],"timestamp":"2026-07-18T06:05:44+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":512,"concurrency":112,"num_prompts":560,"warmup_requests":112,"attempt":1,"gain_pct":17.384035,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c112_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c112_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":640,"failed":0,"duration_s":65.92865188902942,"request_tps":9.707463775798766,"input_tps":9940.442906417937,"output_tps":4970.221453208968,"total_tps":14910.664359626904,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":705.3415620175656,"ttft_p95_ms":2196.1360268993303,"ttft_p99_ms":2223.2738859654637,"tpot_p50_ms":23.27697240701264,"tpot_p95_ms":33.55204214883803,"tpot_p99_ms":43.924380493199514,"e2e_p50_ms":12575.164803507505,"e2e_p95_ms":17870.952806438418,"e2e_p99_ms":22888.23473083845,"itl_p50_ms":85.32809803728014,"itl_p95_ms":272.76630958076566,"itl_p99_ms":425.1585264969617,"validation_errors":[],"timestamp":"2026-07-18T06:07:35+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":512,"concurrency":128,"num_prompts":640,"warmup_requests":128,"attempt":1,"gain_pct":11.67666,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c128_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c128_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":720,"failed":0,"duration_s":74.51672742096707,"request_tps":9.66226007125228,"input_tps":9894.154312962335,"output_tps":4947.077156481168,"total_tps":14841.2314694435,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":779.7015969990753,"ttft_p95_ms":2148.9872895908775,"ttft_p99_ms":2186.1053771193833,"tpot_p50_ms":26.096645865904684,"tpot_p95_ms":38.22186655026505,"tpot_p99_ms":52.803314683850346,"e2e_p50_ms":14216.530876001343,"e2e_p95_ms":20182.12138136441,"e2e_p99_ms":27444.90165219581,"itl_p50_ms":90.15618203557096,"itl_p95_ms":296.3983295223442,"itl_p99_ms":357.9051329626236,"validation_errors":[],"timestamp":"2026-07-18T06:09:32+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":512,"concurrency":144,"num_prompts":720,"warmup_requests":144,"attempt":1,"gain_pct":-0.465659,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c144_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c144_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":800,"failed":0,"duration_s":80.94412470801035,"request_tps":9.883360934296826,"input_tps":10120.56159671995,"output_tps":5060.280798359975,"total_tps":15180.842395079926,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":817.0523729932029,"ttft_p95_ms":2160.506858190638,"ttft_p99_ms":2596.3993154582568,"tpot_p50_ms":28.5446925156881,"tpot_p95_ms":40.86765087402261,"tpot_p99_ms":51.829306476499106,"e2e_p50_ms":15224.834578490118,"e2e_p95_ms":21651.94712994562,"e2e_p99_ms":27727.076973153744,"itl_p50_ms":91.33397502591833,"itl_p95_ms":323.4762603940908,"itl_p99_ms":466.51894136564806,"validation_errors":[],"timestamp":"2026-07-18T06:11:36+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":512,"concurrency":160,"num_prompts":800,"warmup_requests":160,"attempt":1,"gain_pct":2.288293,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c160_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c160_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":880,"failed":0,"duration_s":82.37942389096133,"request_tps":10.682279123058464,"input_tps":10938.653822011867,"output_tps":5469.326911005934,"total_tps":16407.9807330178,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":808.5258149949368,"ttft_p95_ms":2185.678539928631,"ttft_p99_ms":2708.837538654916,"tpot_p50_ms":28.483459440291423,"tpot_p95_ms":41.80993197615431,"tpot_p99_ms":56.03248846294122,"e2e_p50_ms":15369.89451549016,"e2e_p95_ms":22329.882923603873,"e2e_p99_ms":29870.68173680455,"itl_p50_ms":92.48872502939776,"itl_p95_ms":336.2632551579736,"itl_p99_ms":459.590140157379,"validation_errors":[],"timestamp":"2026-07-18T06:13:45+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":512,"concurrency":176,"num_prompts":880,"warmup_requests":176,"attempt":1,"gain_pct":8.083467,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c176_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c176_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":960,"failed":0,"duration_s":88.2393257630174,"request_tps":10.879502893961961,"input_tps":11140.610963417048,"output_tps":5570.305481708524,"total_tps":16710.91644512557,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":818.0757954833098,"ttft_p95_ms":3392.9334083251883,"ttft_p99_ms":3890.629361111205,"tpot_p50_ms":30.178498926628542,"tpot_p95_ms":44.65960393059582,"tpot_p99_ms":58.68115649015938,"e2e_p50_ms":16279.200399003457,"e2e_p95_ms":23838.785342537445,"e2e_p99_ms":31727.328759945813,"itl_p50_ms":96.30524198291823,"itl_p95_ms":351.4928894059266,"itl_p99_ms":443.0101213592569,"validation_errors":[],"timestamp":"2026-07-18T06:16:00+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":512,"concurrency":192,"num_prompts":960,"warmup_requests":192,"attempt":1,"gain_pct":1.846271,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c192_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c192_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":1040,"failed":0,"duration_s":94.6393444329733,"request_tps":10.98908710992353,"input_tps":11252.825200561694,"output_tps":5626.412600280847,"total_tps":16879.23780084254,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":873.2118094922043,"ttft_p95_ms":3666.131964608212,"ttft_p99_ms":4152.719569681211,"tpot_p50_ms":32.99890703232567,"tpot_p95_ms":47.70312925780519,"tpot_p99_ms":62.13896436832977,"e2e_p50_ms":17998.588679998647,"e2e_p95_ms":25517.647617435432,"e2e_p99_ms":32779.968169264605,"itl_p50_ms":111.09803803265095,"itl_p95_ms":349.11071779206395,"itl_p99_ms":502.9302744939924,"validation_errors":[],"timestamp":"2026-07-18T06:18:21+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":512,"concurrency":208,"num_prompts":1040,"warmup_requests":208,"attempt":1,"gain_pct":1.007254,"plateau_streak":2,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c208_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c208_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":79.60508835199289,"request_tps":1.0049608844884501,"input_tps":1029.079945716173,"output_tps":1029.079945716173,"total_tps":2058.159891432346,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":407.6839059998747,"ttft_p95_ms":646.3127308990806,"ttft_p99_ms":650.1733763440278,"tpot_p50_ms":14.99043578151245,"tpot_p95_ms":21.575890763662525,"tpot_p99_ms":25.49900868735903,"e2e_p50_ms":15627.387857995927,"e2e_p95_ms":22628.760430356488,"e2e_p99_ms":26501.344572689814,"itl_p50_ms":86.48320799693465,"itl_p95_ms":94.70463091274719,"itl_p99_ms":245.08925339439855,"validation_errors":[],"timestamp":"2026-07-18T06:20:20+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":1024,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c16_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c16_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":82.40937535301782,"request_tps":1.9415266687146515,"input_tps":1988.1233087638032,"output_tps":1988.1233087638032,"total_tps":3976.2466175276063,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":380.96536850207485,"ttft_p95_ms":771.6618337493856,"ttft_p99_ms":1090.0720741914117,"tpot_p50_ms":14.856883408125073,"tpot_p95_ms":20.11683644709914,"tpot_p99_ms":25.00275330771196,"e2e_p50_ms":15658.09249150334,"e2e_p95_ms":20909.431401942824,"e2e_p99_ms":26350.48865318065,"itl_p50_ms":87.2272599954158,"itl_p95_ms":111.63111538626246,"itl_p99_ms":241.28754552220926,"validation_errors":[],"timestamp":"2026-07-18T06:22:26+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":1024,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":93.194253,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c32_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c32_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":85.00673010299215,"request_tps":2.8233058689496895,"input_tps":2891.065209804482,"output_tps":2891.065209804482,"total_tps":5782.130419608964,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":440.538701514015,"ttft_p95_ms":983.0382429150632,"ttft_p99_ms":1009.5002488500904,"tpot_p50_ms":15.699050796200236,"tpot_p95_ms":21.662628550480395,"tpot_p99_ms":26.47584018182039,"e2e_p50_ms":16486.418849002803,"e2e_p95_ms":22700.456596395812,"e2e_p99_ms":27562.34914322436,"itl_p50_ms":85.44969401555136,"itl_p95_ms":232.69079682067968,"itl_p99_ms":249.8541458428372,"validation_errors":[],"timestamp":"2026-07-18T06:24:34+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":1024,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":45.416796,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c48_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c48_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":86.14200012700167,"request_tps":3.714796493327467,"input_tps":3803.9516091673263,"output_tps":3803.9516091673263,"total_tps":7607.903218334653,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":449.6113909990527,"ttft_p95_ms":1276.2057628744515,"ttft_p99_ms":1329.880426157033,"tpot_p50_ms":15.734053132464954,"tpot_p95_ms":21.354728069436693,"tpot_p99_ms":28.3636371615892,"e2e_p50_ms":16600.10835848516,"e2e_p95_ms":22205.90306748054,"e2e_p99_ms":29296.646206514564,"itl_p50_ms":83.68316697306,"itl_p95_ms":224.11733574408572,"itl_p99_ms":254.99584996083286,"validation_errors":[],"timestamp":"2026-07-18T06:26:43+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":1024,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":31.576126,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c64_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c64_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":400,"failed":0,"duration_s":96.77078562101815,"request_tps":4.133478894823831,"input_tps":4232.682388299603,"output_tps":4232.682388299603,"total_tps":8465.364776599206,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":561.9892320246436,"ttft_p95_ms":1378.721483022673,"ttft_p99_ms":1713.1758719490608,"tpot_p50_ms":17.83587148778695,"tpot_p95_ms":25.06456940303662,"tpot_p99_ms":36.104098607352746,"e2e_p50_ms":18751.656215521507,"e2e_p95_ms":26191.79380781424,"e2e_p99_ms":37671.6498607845,"itl_p50_ms":84.37576299184002,"itl_p95_ms":244.57347715506336,"itl_p99_ms":270.0874079117784,"validation_errors":[],"timestamp":"2026-07-18T06:29:03+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":1024,"concurrency":80,"num_prompts":400,"warmup_requests":80,"attempt":1,"gain_pct":11.270669,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c80_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c80_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":480,"failed":0,"duration_s":103.45821136102313,"request_tps":4.639554402550162,"input_tps":4750.9037082113655,"output_tps":4750.9037082113655,"total_tps":9501.807416422731,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":567.3579415015411,"ttft_p95_ms":1721.111396467313,"ttft_p99_ms":1916.990506062866,"tpot_p50_ms":18.346830842620943,"tpot_p95_ms":26.129881059708232,"tpot_p99_ms":34.41988057278302,"e2e_p50_ms":19279.41034050309,"e2e_p95_ms":27305.577348178478,"e2e_p99_ms":36032.53459320635,"itl_p50_ms":84.42453999305144,"itl_p95_ms":244.57448499160822,"itl_p99_ms":279.7343339479994,"validation_errors":[],"timestamp":"2026-07-18T06:31:31+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":1024,"concurrency":96,"num_prompts":480,"warmup_requests":96,"attempt":1,"gain_pct":12.243331,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c96_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c96_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":560,"failed":0,"duration_s":115.63065708597424,"request_tps":4.843006293595878,"input_tps":4959.238444642179,"output_tps":4959.238444642179,"total_tps":9918.476889284359,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":589.3313985143322,"ttft_p95_ms":2354.8432007693914,"ttft_p99_ms":2389.804806677275,"tpot_p50_ms":19.614289873440086,"tpot_p95_ms":29.31918532144971,"tpot_p99_ms":37.76357376628733,"e2e_p50_ms":20854.002407490043,"e2e_p95_ms":30819.542662441378,"e2e_p99_ms":39439.85810186534,"itl_p50_ms":85.40382399223745,"itl_p95_ms":247.00330770574507,"itl_p99_ms":279.5329240954015,"validation_errors":[],"timestamp":"2026-07-18T06:34:12+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":1024,"concurrency":112,"num_prompts":560,"warmup_requests":112,"attempt":1,"gain_pct":4.38516,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c112_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c112_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":640,"failed":0,"duration_s":117.6086616999819,"request_tps":5.441776062656264,"input_tps":5572.3786881600145,"output_tps":5572.3786881600145,"total_tps":11144.757376320029,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":661.2272315251175,"ttft_p95_ms":2326.7924885672983,"ttft_p99_ms":2497.7287154569094,"tpot_p50_ms":21.024313810866836,"tpot_p95_ms":28.854914351630697,"tpot_p99_ms":40.91709392882915,"e2e_p50_ms":22263.292461517267,"e2e_p95_ms":30589.105334892512,"e2e_p99_ms":42680.481267386946,"itl_p50_ms":86.03650802979246,"itl_p95_ms":258.82153940037824,"itl_p99_ms":319.16813996620505,"validation_errors":[],"timestamp":"2026-07-18T06:36:56+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":1024,"concurrency":128,"num_prompts":640,"warmup_requests":128,"attempt":1,"gain_pct":12.363597,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c128_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c128_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":720,"failed":0,"duration_s":121.84311938501196,"request_tps":5.909238072975403,"input_tps":6051.0597867268125,"output_tps":6051.0597867268125,"total_tps":12102.119573453625,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":645.5512469692621,"ttft_p95_ms":2366.4758470025845,"ttft_p99_ms":2717.24164929532,"tpot_p50_ms":21.916951748776,"tpot_p95_ms":30.98207827671288,"tpot_p99_ms":40.026360603270945,"e2e_p50_ms":23095.0476184953,"e2e_p95_ms":32388.192751593295,"e2e_p99_ms":41596.61478766298,"itl_p50_ms":85.4999459697865,"itl_p95_ms":262.2505075123627,"itl_p99_ms":354.91175132337963,"validation_errors":[],"timestamp":"2026-07-18T06:39:45+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":1024,"concurrency":144,"num_prompts":720,"warmup_requests":144,"attempt":1,"gain_pct":8.590247,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c144_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c144_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":800,"failed":0,"duration_s":130.36483467300422,"request_tps":6.136624205497212,"input_tps":6283.9031864291455,"output_tps":6283.9031864291455,"total_tps":12567.806372858291,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":707.1435815014411,"ttft_p95_ms":4009.1303995955964,"ttft_p99_ms":4045.650853659608,"tpot_p50_ms":22.670410281989017,"tpot_p95_ms":32.424074357759224,"tpot_p99_ms":41.80275160992321,"e2e_p50_ms":24320.77596648014,"e2e_p95_ms":34313.108163967256,"e2e_p99_ms":43657.70168919,"itl_p50_ms":87.407415965572,"itl_p95_ms":270.36332882707944,"itl_p99_ms":387.61912281159175,"validation_errors":[],"timestamp":"2026-07-18T06:42:42+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":1024,"concurrency":160,"num_prompts":800,"warmup_requests":160,"attempt":1,"gain_pct":3.847977,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c160_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c160_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":150.2026805789792,"request_tps":0.5326136636951336,"input_tps":545.3963916238168,"output_tps":1090.7927832476337,"total_tps":1636.1891748714504,"mean_input_tokens":1024.0,"mean_output_tokens":2048.0,"ttft_p50_ms":412.42364401114173,"ttft_p95_ms":786.9902191421716,"ttft_p99_ms":794.0786928171292,"tpot_p50_ms":15.269406251588284,"tpot_p95_ms":18.36971390107516,"tpot_p99_ms":20.337623992956605,"e2e_p50_ms":31775.435112504056,"e2e_p95_ms":37856.09824323037,"e2e_p99_ms":42187.99560111656,"itl_p50_ms":90.49791301367804,"itl_p95_ms":95.77380621340126,"itl_p99_ms":232.0926433452405,"validation_errors":[],"timestamp":"2026-07-18T06:45:55+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":2048,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c16_i1024_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c16_i1024_o2048_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":117.95753514801618,"request_tps":1.3564203405846675,"input_tps":1388.9744287586996,"output_tps":2777.948857517399,"total_tps":4166.923286276099,"mean_input_tokens":1024.0,"mean_output_tokens":2048.0,"ttft_p50_ms":377.1132485126145,"ttft_p95_ms":1115.7573598669842,"ttft_p99_ms":1141.37381040724,"tpot_p50_ms":11.421417416702148,"tpot_p95_ms":14.898739847872175,"tpot_p99_ms":15.63809159308012,"e2e_p50_ms":23789.561162004247,"e2e_p95_ms":30796.54847579077,"e2e_p99_ms":32178.349624481634,"itl_p50_ms":32.83133695367724,"itl_p95_ms":94.11892603384331,"itl_p99_ms":235.87229077238592,"validation_errors":[],"timestamp":"2026-07-18T06:48:33+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":2048,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":154.672464,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c32_i1024_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c32_i1024_o2048_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":160.89941876399098,"request_tps":1.4916150837812199,"input_tps":1527.4138457919692,"output_tps":3054.8276915839383,"total_tps":4582.241537375908,"mean_input_tokens":1024.0,"mean_output_tokens":2048.0,"ttft_p50_ms":426.05561050004326,"ttft_p95_ms":1277.4677553446963,"ttft_p99_ms":1304.0140518621774,"tpot_p50_ms":15.076618976060153,"tpot_p95_ms":19.023783777965946,"tpot_p99_ms":25.538602627427466,"e2e_p50_ms":31377.666410029633,"e2e_p95_ms":39397.83548365229,"e2e_p99_ms":52611.722223298806,"itl_p50_ms":85.55669352062978,"itl_p95_ms":205.58206900022898,"itl_p99_ms":252.00597773422484,"validation_errors":[],"timestamp":"2026-07-18T06:51:58+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":2048,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":9.967024,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c48_i1024_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c48_i1024_o2048_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":172.70216718502343,"request_tps":1.8529008941571066,"input_tps":1897.3705156168771,"output_tps":3794.7410312337543,"total_tps":5692.111546850631,"mean_input_tokens":1024.0,"mean_output_tokens":2048.0,"ttft_p50_ms":414.0744580072351,"ttft_p95_ms":1727.1969733585138,"ttft_p99_ms":1924.1672205214854,"tpot_p50_ms":15.014605062285666,"tpot_p95_ms":19.66661052908968,"tpot_p99_ms":25.776467337091642,"e2e_p50_ms":31166.219675011234,"e2e_p95_ms":40848.77990150417,"e2e_p99_ms":53181.58955330902,"itl_p50_ms":85.4593864933122,"itl_p95_ms":183.95498226163903,"itl_p99_ms":248.9450521208345,"validation_errors":[],"timestamp":"2026-07-18T06:55:33+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":2048,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":24.221115,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c64_i1024_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c64_i1024_o2048_a1.log"} +{"status":"COMPLETED","completed":400,"failed":0,"duration_s":182.20002251997357,"request_tps":2.1953894103177194,"input_tps":2248.0787561653447,"output_tps":4496.157512330689,"total_tps":6744.236268496034,"mean_input_tokens":1024.0,"mean_output_tokens":2048.0,"ttft_p50_ms":520.9632039768621,"ttft_p95_ms":1617.8713238972705,"ttft_p99_ms":1933.555815393338,"tpot_p50_ms":16.289294077917543,"tpot_p95_ms":21.209498819380457,"tpot_p99_ms":30.203393346880382,"e2e_p50_ms":33902.59466099087,"e2e_p95_ms":43817.069502983904,"e2e_p99_ms":62624.30305940797,"itl_p50_ms":86.1800599959679,"itl_p95_ms":231.15397048532026,"itl_p99_ms":253.06931206258017,"validation_errors":[],"timestamp":"2026-07-18T06:59:22+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":2048,"concurrency":80,"num_prompts":400,"warmup_requests":80,"attempt":1,"gain_pct":18.483909,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c80_i1024_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c80_i1024_o2048_a1.log"} +{"status":"COMPLETED","completed":480,"failed":0,"duration_s":190.82113397598732,"request_tps":2.515444647029519,"input_tps":2575.8153185582273,"output_tps":5151.630637116455,"total_tps":7727.445955674682,"mean_input_tokens":1024.0,"mean_output_tokens":2048.0,"ttft_p50_ms":495.76087450259365,"ttft_p95_ms":2314.66916478239,"ttft_p99_ms":2336.5911875566235,"tpot_p50_ms":16.98090220421007,"tpot_p95_ms":21.61316962647204,"tpot_p99_ms":29.18472666850834,"e2e_p50_ms":35335.16073349165,"e2e_p95_ms":44679.23246457938,"e2e_p99_ms":60059.751407711294,"itl_p50_ms":86.45145650370978,"itl_p95_ms":229.65408470481634,"itl_p99_ms":277.2906931198668,"validation_errors":[],"timestamp":"2026-07-18T07:03:22+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":2048,"concurrency":96,"num_prompts":480,"warmup_requests":96,"attempt":1,"gain_pct":14.578518,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c96_i1024_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c96_i1024_o2048_a1.log"} +{"status":"COMPLETED","completed":560,"failed":0,"duration_s":198.0128950009821,"request_tps":2.828098644773728,"input_tps":2895.9730122482974,"output_tps":5791.946024496595,"total_tps":8687.919036744894,"mean_input_tokens":1024.0,"mean_output_tokens":2048.0,"ttft_p50_ms":563.0678515008185,"ttft_p95_ms":2601.613403094234,"ttft_p99_ms":2638.8564323534956,"tpot_p50_ms":17.695160321935667,"tpot_p95_ms":23.785689747204458,"tpot_p99_ms":30.024729573240815,"e2e_p50_ms":36994.48036099784,"e2e_p95_ms":49434.97108165464,"e2e_p99_ms":61867.70613670813,"itl_p50_ms":85.83279198501259,"itl_p95_ms":235.87675699964163,"itl_p99_ms":263.72203486971546,"validation_errors":[],"timestamp":"2026-07-18T07:07:28+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":2048,"concurrency":112,"num_prompts":560,"warmup_requests":112,"attempt":1,"gain_pct":12.429373,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c112_i1024_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c112_i1024_o2048_a1.log"} +{"status":"COMPLETED","completed":640,"failed":0,"duration_s":191.7709249429754,"request_tps":3.3373150814718606,"input_tps":3417.4106434271853,"output_tps":6834.821286854371,"total_tps":10252.231930281556,"mean_input_tokens":1024.0,"mean_output_tokens":2048.0,"ttft_p50_ms":545.8941819961183,"ttft_p95_ms":2985.110574340797,"ttft_p99_ms":3784.7169642412337,"tpot_p50_ms":17.484521590138893,"tpot_p95_ms":23.729226833432495,"tpot_p99_ms":29.022526356002498,"e2e_p50_ms":36657.2671844915,"e2e_p95_ms":49005.68139890381,"e2e_p99_ms":60119.90727402619,"itl_p50_ms":74.2864619824104,"itl_p95_ms":234.78238438256076,"itl_p99_ms":279.6242060582153,"validation_errors":[],"timestamp":"2026-07-18T07:11:25+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":2048,"concurrency":128,"num_prompts":640,"warmup_requests":128,"attempt":1,"gain_pct":18.005611,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c128_i1024_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c128_i1024_o2048_a1.log"} +{"status":"COMPLETED","completed":720,"failed":0,"duration_s":215.48066792503232,"request_tps":3.341367032751609,"input_tps":3421.5598415376476,"output_tps":6843.119683075295,"total_tps":10264.679524612942,"mean_input_tokens":1024.0,"mean_output_tokens":2048.0,"ttft_p50_ms":613.2692910032347,"ttft_p95_ms":4315.956009295769,"ttft_p99_ms":4790.9273872181075,"tpot_p50_ms":19.44166549584559,"tpot_p95_ms":25.579141268379985,"tpot_p99_ms":31.23587258200489,"e2e_p50_ms":40996.78571699769,"e2e_p95_ms":52883.977984407065,"e2e_p99_ms":64622.08156351694,"itl_p50_ms":85.18210495822132,"itl_p95_ms":244.40788499196046,"itl_p99_ms":323.3815783413594,"validation_errors":[],"timestamp":"2026-07-18T07:15:50+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":2048,"concurrency":144,"num_prompts":720,"warmup_requests":144,"attempt":1,"gain_pct":0.121414,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c144_i1024_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c144_i1024_o2048_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":286.4525537529844,"request_tps":0.2792783619900492,"input_tps":285.98104267781036,"output_tps":1143.9241707112415,"total_tps":1429.9052133890518,"mean_input_tokens":1024.0,"mean_output_tokens":4096.0,"ttft_p50_ms":415.5090095300693,"ttft_p95_ms":689.0627054992365,"ttft_p99_ms":921.6737110452959,"tpot_p50_ms":14.486679752381184,"tpot_p95_ms":17.421569866222082,"tpot_p99_ms":19.67688954435928,"e2e_p50_ms":60008.90947348671,"e2e_p95_ms":71877.04913988418,"e2e_p99_ms":81054.14829951475,"itl_p50_ms":86.76057099364698,"itl_p95_ms":92.69424534868449,"itl_p99_ms":224.3123927898705,"validation_errors":[],"timestamp":"2026-07-18T07:21:15+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":4096,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c16_i1024_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c16_i1024_o4096_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":271.0849012370454,"request_tps":0.590220994492389,"input_tps":604.3862983602063,"output_tps":2417.545193440825,"total_tps":3021.931491801032,"mean_input_tokens":1024.0,"mean_output_tokens":4096.0,"ttft_p50_ms":407.1906325407326,"ttft_p95_ms":844.9148285115369,"ttft_p99_ms":1179.8500347114166,"tpot_p50_ms":13.842042536872482,"tpot_p95_ms":16.733418963369807,"tpot_p99_ms":19.06151877171292,"e2e_p50_ms":57090.217068005586,"e2e_p95_ms":69344.9716752977,"e2e_p99_ms":78560.88941551976,"itl_p50_ms":85.27005347423255,"itl_p95_ms":90.64666501362808,"itl_p99_ms":235.04720430064475,"validation_errors":[],"timestamp":"2026-07-18T07:26:29+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":4096,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":111.337889,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c32_i1024_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c32_i1024_o4096_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":300.4929018939729,"request_tps":0.7986877509828254,"input_tps":817.8562570064132,"output_tps":3271.425028025653,"total_tps":4089.281285032066,"mean_input_tokens":1024.0,"mean_output_tokens":4096.0,"ttft_p50_ms":424.7485904779751,"ttft_p95_ms":1871.8861988949357,"ttft_p99_ms":1910.93933450873,"tpot_p50_ms":13.911099414409664,"tpot_p95_ms":17.232444162311523,"tpot_p99_ms":20.901014696250463,"e2e_p50_ms":57377.79916700674,"e2e_p95_ms":71821.09534822812,"e2e_p99_ms":86749.9072694662,"itl_p50_ms":85.32200151239522,"itl_p95_ms":93.72161013016013,"itl_p99_ms":246.86326112074318,"validation_errors":[],"timestamp":"2026-07-18T07:32:15+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":4096,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":35.320119,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c48_i1024_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c48_i1024_o4096_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":302.935103175987,"request_tps":1.0563318567082642,"input_tps":1081.6838212692626,"output_tps":4326.73528507705,"total_tps":5408.419106346313,"mean_input_tokens":1024.0,"mean_output_tokens":4096.0,"ttft_p50_ms":417.706198990345,"ttft_p95_ms":1856.1540883383714,"ttft_p99_ms":1905.4785095743136,"tpot_p50_ms":13.533893554826506,"tpot_p95_ms":17.173995611355085,"tpot_p99_ms":21.934312939626093,"e2e_p50_ms":55869.906825508224,"e2e_p95_ms":71344.58177497439,"e2e_p99_ms":90319.40234442882,"itl_p50_ms":84.37019103439525,"itl_p95_ms":106.18850248283707,"itl_p99_ms":245.71708898292854,"validation_errors":[],"timestamp":"2026-07-18T07:38:07+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":4096,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":32.258427,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c64_i1024_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c64_i1024_o4096_a1.log"} +{"status":"COMPLETED","completed":400,"failed":0,"duration_s":341.87100440997165,"request_tps":1.1700319560307608,"input_tps":1198.112722975499,"output_tps":4792.450891901996,"total_tps":5990.563614877496,"mean_input_tokens":1024.0,"mean_output_tokens":4096.0,"ttft_p50_ms":446.76159002119675,"ttft_p95_ms":1873.2566662860336,"ttft_p99_ms":2161.3702099205693,"tpot_p50_ms":15.607769269234943,"tpot_p95_ms":19.87255855987314,"tpot_p99_ms":24.99559675207687,"e2e_p50_ms":64425.299259019084,"e2e_p95_ms":81810.1578707312,"e2e_p99_ms":102929.66239572501,"itl_p50_ms":86.1059550079517,"itl_p95_ms":184.0911040082579,"itl_p99_ms":252.45182590559128,"validation_errors":[],"timestamp":"2026-07-18T07:44:39+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":4096,"concurrency":80,"num_prompts":400,"warmup_requests":80,"attempt":1,"gain_pct":10.763672,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c80_i1024_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c80_i1024_o4096_a1.log"} +{"status":"COMPLETED","completed":480,"failed":0,"duration_s":325.0703872279846,"request_tps":1.4766032799639703,"input_tps":1512.0417586831056,"output_tps":6048.1670347324225,"total_tps":7560.208793415528,"mean_input_tokens":1024.0,"mean_output_tokens":4096.0,"ttft_p50_ms":475.81340750912204,"ttft_p95_ms":3385.440351831494,"ttft_p99_ms":3407.3883338231826,"tpot_p50_ms":14.79176238607911,"tpot_p95_ms":18.53867575477482,"tpot_p99_ms":23.300856129286082,"e2e_p50_ms":61131.08222649316,"e2e_p95_ms":76666.51392581694,"e2e_p99_ms":95857.53102720773,"itl_p50_ms":82.46731100371107,"itl_p95_ms":185.86199792625848,"itl_p99_ms":250.61514202738184,"validation_errors":[],"timestamp":"2026-07-18T07:50:56+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":4096,"concurrency":96,"num_prompts":480,"warmup_requests":96,"attempt":1,"gain_pct":26.201962,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c96_i1024_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c96_i1024_o4096_a1.log"} +{"status":"COMPLETED","completed":560,"failed":0,"duration_s":363.34800309001,"request_tps":1.5412221760890608,"input_tps":1578.2115083151982,"output_tps":6312.846033260793,"total_tps":7891.05754157599,"mean_input_tokens":1024.0,"mean_output_tokens":4096.0,"ttft_p50_ms":501.94702998851426,"ttft_p95_ms":3465.4167868313375,"ttft_p99_ms":4382.007399628637,"tpot_p50_ms":16.16872577032931,"tpot_p95_ms":20.624749478169058,"tpot_p99_ms":25.129214034420755,"e2e_p50_ms":66693.46437448985,"e2e_p95_ms":85086.1284977087,"e2e_p99_ms":104938.15359997434,"itl_p50_ms":85.38894102093764,"itl_p95_ms":222.08589443471269,"itl_p99_ms":258.03625810309325,"validation_errors":[],"timestamp":"2026-07-18T07:57:48+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":4096,"concurrency":112,"num_prompts":560,"warmup_requests":112,"attempt":1,"gain_pct":4.376185,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c112_i1024_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c112_i1024_o4096_a1.log"} +{"status":"COMPLETED","completed":640,"failed":0,"duration_s":367.5936064379639,"request_tps":1.741053132565863,"input_tps":1782.8384077474436,"output_tps":7131.3536309897745,"total_tps":8914.192038737217,"mean_input_tokens":1024.0,"mean_output_tokens":4096.0,"ttft_p50_ms":503.7476145080291,"ttft_p95_ms":3707.6142597419675,"ttft_p99_ms":5240.543840374448,"tpot_p50_ms":16.523283554334306,"tpot_p95_ms":20.45567069442741,"tpot_p99_ms":24.272728985995375,"e2e_p50_ms":68343.48615599447,"e2e_p95_ms":84932.1826358413,"e2e_p99_ms":100044.71657776742,"itl_p50_ms":85.80058900406584,"itl_p95_ms":205.75312752043828,"itl_p99_ms":264.4091584952548,"validation_errors":[],"timestamp":"2026-07-18T08:04:50+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":4096,"concurrency":128,"num_prompts":640,"warmup_requests":128,"attempt":1,"gain_pct":12.965746,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c128_i1024_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c128_i1024_o4096_a1.log"} +{"status":"COMPLETED","completed":720,"failed":0,"duration_s":382.23730332101695,"request_tps":1.883646608387977,"input_tps":1928.8541269892885,"output_tps":7715.416507957154,"total_tps":9644.270634946442,"mean_input_tokens":1024.0,"mean_output_tokens":4096.0,"ttft_p50_ms":564.1488605178893,"ttft_p95_ms":4711.063481468591,"ttft_p99_ms":5616.900574608007,"tpot_p50_ms":17.228082733085806,"tpot_p95_ms":21.41927099644484,"tpot_p99_ms":26.30109958961459,"e2e_p50_ms":71350.61672850861,"e2e_p95_ms":89059.54032108128,"e2e_p99_ms":108405.47380972354,"itl_p50_ms":83.6159239988774,"itl_p95_ms":233.58785651507787,"itl_p99_ms":270.53108153806534,"validation_errors":[],"timestamp":"2026-07-18T08:12:08+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":4096,"concurrency":144,"num_prompts":720,"warmup_requests":144,"attempt":1,"gain_pct":8.19007,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c144_i1024_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c144_i1024_o4096_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":25.14324134401977,"request_tps":3.1817695620627573,"input_tps":13032.528126209054,"output_tps":407.26650394403293,"total_tps":13439.794630153086,"mean_input_tokens":4096.0,"mean_output_tokens":128.0,"ttft_p50_ms":2044.6934099891223,"ttft_p95_ms":3140.3355846501654,"ttft_p99_ms":3185.3853395045735,"tpot_p50_ms":21.510897972437693,"tpot_p95_ms":40.948796024436945,"tpot_p99_ms":50.971546800001214,"e2e_p50_ms":4487.985536485212,"e2e_p95_ms":7218.095048022223,"e2e_p99_ms":8454.547385666496,"itl_p50_ms":79.83844351838343,"itl_p95_ms":584.9501292366767,"itl_p99_ms":959.9978392367484,"validation_errors":[],"timestamp":"2026-07-18T08:13:15+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":128,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c16_i4096_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c16_i4096_o128_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":35.277848193014506,"request_tps":4.5354240180579435,"input_tps":18577.096777965337,"output_tps":580.5342743114168,"total_tps":19157.631052276753,"mean_input_tokens":4096.0,"mean_output_tokens":128.0,"ttft_p50_ms":2564.790732518304,"ttft_p95_ms":3735.6042621133383,"ttft_p99_ms":3963.436060131644,"tpot_p50_ms":33.13555822439132,"tpot_p95_ms":53.314201747375265,"tpot_p99_ms":61.22204257285784,"e2e_p50_ms":6910.391120996792,"e2e_p95_ms":9509.276080570999,"e2e_p99_ms":11231.668129330501,"itl_p50_ms":84.45805800147355,"itl_p95_ms":865.8107959781773,"itl_p99_ms":1174.7601065901115,"validation_errors":[],"timestamp":"2026-07-18T08:14:37+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":128,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":42.544076,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c32_i4096_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c32_i4096_o128_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":44.094182369008195,"request_tps":5.4428948923812035,"input_tps":22294.09747919341,"output_tps":696.690546224794,"total_tps":22990.788025418202,"mean_input_tokens":4096.0,"mean_output_tokens":128.0,"ttft_p50_ms":2955.036316969199,"ttft_p95_ms":4710.542809718754,"ttft_p99_ms":5542.321427653078,"tpot_p50_ms":46.23467871652527,"tpot_p95_ms":68.56807670970795,"tpot_p99_ms":76.70138269513899,"e2e_p50_ms":8741.505275975214,"e2e_p95_ms":11842.305685038446,"e2e_p99_ms":13357.960334651869,"itl_p50_ms":85.68529249168932,"itl_p95_ms":1113.985140717705,"itl_p99_ms":1226.400818837574,"validation_errors":[],"timestamp":"2026-07-18T08:16:05+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":128,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":20.008512,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c48_i4096_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c48_i4096_o128_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":27.779251430998556,"request_tps":2.879847219739294,"input_tps":11795.854212052149,"output_tps":737.2408882532593,"total_tps":12533.095100305409,"mean_input_tokens":4096.0,"mean_output_tokens":256.0,"ttft_p50_ms":1009.3001775094308,"ttft_p95_ms":1761.136087559862,"ttft_p99_ms":1769.271083366475,"tpot_p50_ms":17.779027513689456,"tpot_p95_ms":25.740632220472698,"tpot_p99_ms":30.406351056125672,"e2e_p50_ms":5257.365172990831,"e2e_p95_ms":7808.435994916362,"e2e_p99_ms":8583.352297879748,"itl_p50_ms":87.52153647947125,"itl_p95_ms":238.8859192840755,"itl_p99_ms":734.5063630462391,"validation_errors":[],"timestamp":"2026-07-18T08:17:17+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":256,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c16_i4096_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c16_i4096_o256_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":40.67441730201244,"request_tps":3.9336765124864788,"input_tps":16112.338995144617,"output_tps":1007.0211871965386,"total_tps":17119.360182341155,"mean_input_tokens":4096.0,"mean_output_tokens":256.0,"ttft_p50_ms":1262.195919000078,"ttft_p95_ms":2533.170077975956,"ttft_p99_ms":2911.352904807427,"tpot_p50_ms":26.25312650001005,"tpot_p95_ms":37.3194479382501,"tpot_p99_ms":42.66734380195118,"e2e_p50_ms":8018.58487847494,"e2e_p95_ms":10641.756715002699,"e2e_p99_ms":12253.424837017661,"itl_p50_ms":85.9207330213394,"itl_p95_ms":665.0950040348107,"itl_p99_ms":863.8707465113839,"validation_errors":[],"timestamp":"2026-07-18T08:18:39+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":256,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":36.593236,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c32_i4096_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c32_i4096_o256_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":49.56147300900193,"request_tps":4.8424710854822335,"input_tps":19834.76156613523,"output_tps":1239.6725978834518,"total_tps":21074.43416401868,"mean_input_tokens":4096.0,"mean_output_tokens":256.0,"ttft_p50_ms":1913.3766209997702,"ttft_p95_ms":2792.356653462047,"ttft_p99_ms":3445.413520763974,"tpot_p50_ms":30.673128366698602,"tpot_p95_ms":50.99916865252525,"tpot_p99_ms":58.82784484406959,"e2e_p50_ms":9569.53915549093,"e2e_p95_ms":14702.6621985191,"e2e_p99_ms":17028.99486232374,"itl_p50_ms":39.27048548939638,"itl_p95_ms":755.4094956838525,"itl_p99_ms":957.9466969316127,"validation_errors":[],"timestamp":"2026-07-18T08:20:16+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":256,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":23.102931,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c48_i4096_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c48_i4096_o256_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":64.75158589403145,"request_tps":4.941963900678707,"input_tps":20242.284137179984,"output_tps":1265.142758573749,"total_tps":21507.42689575373,"mean_input_tokens":4096.0,"mean_output_tokens":256.0,"ttft_p50_ms":2097.6294894935563,"ttft_p95_ms":3809.938312097802,"ttft_p99_ms":4630.228929060395,"tpot_p50_ms":42.419102672469236,"tpot_p95_ms":71.72034466998679,"tpot_p99_ms":77.93278053970825,"e2e_p50_ms":12811.064347508363,"e2e_p95_ms":19947.94272412837,"e2e_p99_ms":22549.108817754895,"itl_p50_ms":88.63719602231868,"itl_p95_ms":876.0267587349517,"itl_p99_ms":1066.4783267187886,"validation_errors":[],"timestamp":"2026-07-18T08:22:06+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":256,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":2.054588,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c64_i4096_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c64_i4096_o256_a1.log"} +{"status":"COMPLETED","completed":400,"failed":0,"duration_s":65.75204496603692,"request_tps":6.083460981428229,"input_tps":24917.856179930026,"output_tps":1557.3660112456266,"total_tps":26475.222191175653,"mean_input_tokens":4096.0,"mean_output_tokens":256.0,"ttft_p50_ms":2618.7600245175418,"ttft_p95_ms":4948.899603172322,"ttft_p99_ms":6124.03378896066,"tpot_p50_ms":38.686121345210054,"tpot_p95_ms":72.7337985376453,"tpot_p99_ms":82.82808598739037,"e2e_p50_ms":12103.182285965886,"e2e_p95_ms":20444.19348662194,"e2e_p99_ms":24449.827475112394,"itl_p50_ms":84.22749949386343,"itl_p95_ms":1008.8626540673422,"itl_p99_ms":1292.1951342577813,"validation_errors":[],"timestamp":"2026-07-18T08:23:51+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":256,"concurrency":80,"num_prompts":400,"warmup_requests":80,"attempt":1,"gain_pct":23.098046,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c80_i4096_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c80_i4096_o256_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":38.65030013298383,"request_tps":2.069841624120499,"input_tps":8478.071292397564,"output_tps":1059.7589115496955,"total_tps":9537.83020394726,"mean_input_tokens":4096.0,"mean_output_tokens":512.0,"ttft_p50_ms":620.6444519921206,"ttft_p95_ms":936.0296260594623,"ttft_p99_ms":1100.116894695675,"tpot_p50_ms":15.861129452059329,"tpot_p95_ms":20.232322726409187,"tpot_p99_ms":21.275942957198698,"e2e_p50_ms":8665.136098483345,"e2e_p95_ms":10730.879095272394,"e2e_p99_ms":11450.495356732277,"itl_p50_ms":85.84429597249255,"itl_p95_ms":143.13118097488734,"itl_p99_ms":435.5954355641734,"validation_errors":[],"timestamp":"2026-07-18T08:25:11+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":512,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c16_i4096_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c16_i4096_o512_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":42.873015425982885,"request_tps":3.731951168124114,"input_tps":15286.071984636372,"output_tps":1910.7589980795465,"total_tps":17196.830982715917,"mean_input_tokens":4096.0,"mean_output_tokens":512.0,"ttft_p50_ms":668.6658540274948,"ttft_p95_ms":1169.4314424239544,"ttft_p99_ms":1420.9505053510657,"tpot_p50_ms":16.099248293544843,"tpot_p95_ms":22.06760565841998,"tpot_p99_ms":23.239095193762676,"e2e_p50_ms":8993.9388994826,"e2e_p95_ms":11776.354498250294,"e2e_p99_ms":12846.71451738861,"itl_p50_ms":85.61064099194482,"itl_p95_ms":236.37502964120318,"itl_p99_ms":472.9113015602343,"validation_errors":[],"timestamp":"2026-07-18T08:26:39+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":512,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":80.301291,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c32_i4096_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c32_i4096_o512_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":49.42386413097847,"request_tps":4.85595378305457,"input_tps":19889.98669539152,"output_tps":2486.24833692394,"total_tps":22376.23503231546,"mean_input_tokens":4096.0,"mean_output_tokens":512.0,"ttft_p50_ms":793.7136149848811,"ttft_p95_ms":1675.055955984862,"ttft_p99_ms":1841.4866194489866,"tpot_p50_ms":17.01497044620458,"tpot_p95_ms":27.39431890582145,"tpot_p99_ms":32.02977704269599,"e2e_p50_ms":9689.35536747449,"e2e_p95_ms":14806.62892119726,"e2e_p99_ms":16979.578871557023,"itl_p50_ms":39.837293967138976,"itl_p95_ms":441.6627383790909,"itl_p99_ms":749.6468952018766,"validation_errors":[],"timestamp":"2026-07-18T08:28:19+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":512,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":30.118363,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c48_i4096_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c48_i4096_o512_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":61.71506285399664,"request_tps":5.185119891347189,"input_tps":21238.251074958087,"output_tps":2654.781384369761,"total_tps":23893.032459327846,"mean_input_tokens":4096.0,"mean_output_tokens":512.0,"ttft_p50_ms":1069.9313745135441,"ttft_p95_ms":2400.7142303162254,"ttft_p99_ms":3142.5675217306716,"tpot_p50_ms":21.4160163561634,"tpot_p95_ms":33.89185300649216,"tpot_p99_ms":37.21584633580175,"e2e_p50_ms":12030.632052512374,"e2e_p95_ms":18693.46521483967,"e2e_p99_ms":19924.031569804065,"itl_p50_ms":46.91514201113023,"itl_p95_ms":485.9654659288932,"itl_p99_ms":771.3851305324349,"validation_errors":[],"timestamp":"2026-07-18T08:30:01+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":512,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":6.778609,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c64_i4096_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c64_i4096_o512_a1.log"} +{"status":"COMPLETED","completed":400,"failed":0,"duration_s":76.54443174001062,"request_tps":5.225723033108829,"input_tps":21404.561543613763,"output_tps":2675.5701929517204,"total_tps":24080.131736565483,"mean_input_tokens":4096.0,"mean_output_tokens":512.0,"ttft_p50_ms":1499.2789010284469,"ttft_p95_ms":3061.019398778444,"ttft_p99_ms":3953.5343782708514,"tpot_p50_ms":25.26433131117155,"tpot_p95_ms":44.32831963869024,"tpot_p99_ms":49.97741177445391,"e2e_p50_ms":14020.210307498928,"e2e_p95_ms":23877.992232653196,"e2e_p99_ms":27662.882989548376,"itl_p50_ms":85.73014999274164,"itl_p95_ms":578.1163000850939,"itl_p99_ms":956.9401054899203,"validation_errors":[],"timestamp":"2026-07-18T08:32:00+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":512,"concurrency":80,"num_prompts":400,"warmup_requests":80,"attempt":1,"gain_pct":0.78307,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c80_i4096_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c80_i4096_o512_a1.log"} +{"status":"COMPLETED","completed":480,"failed":0,"duration_s":97.14941271097632,"request_tps":4.940843043776503,"input_tps":20237.693107308558,"output_tps":2529.7116384135697,"total_tps":22767.404745722128,"mean_input_tokens":4096.0,"mean_output_tokens":512.0,"ttft_p50_ms":1925.1214640098624,"ttft_p95_ms":3476.8638460605807,"ttft_p99_ms":3896.5211979969154,"tpot_p50_ms":28.732888989238006,"tpot_p95_ms":61.983515624836976,"tpot_p99_ms":73.63919659307412,"e2e_p50_ms":16370.560151990503,"e2e_p95_ms":33228.584832683555,"e2e_p99_ms":40015.755713438215,"itl_p50_ms":84.44366898038425,"itl_p95_ms":796.659617079422,"itl_p99_ms":961.1965648713526,"validation_errors":[],"timestamp":"2026-07-18T08:34:29+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":512,"concurrency":96,"num_prompts":480,"warmup_requests":96,"attempt":1,"gain_pct":-5.451494,"plateau_streak":2,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c96_i4096_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c96_i4096_o512_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":64.90113524900516,"request_tps":1.2326440776893233,"input_tps":5048.910142215468,"output_tps":1262.227535553867,"total_tps":6311.137677769335,"mean_input_tokens":4096.0,"mean_output_tokens":1024.0,"ttft_p50_ms":398.9584165101405,"ttft_p95_ms":806.4710746024502,"ttft_p99_ms":972.96591009479,"tpot_p50_ms":14.500684037150036,"tpot_p95_ms":17.106465510512475,"tpot_p99_ms":18.807441385535476,"e2e_p50_ms":15434.597595507512,"e2e_p95_ms":18148.971830366645,"e2e_p99_ms":19980.53555313905,"itl_p50_ms":85.7373230101075,"itl_p95_ms":90.90383081929758,"itl_p99_ms":249.85929061251224,"validation_errors":[],"timestamp":"2026-07-18T08:36:17+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":1024,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c16_i4096_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c16_i4096_o1024_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":85.15401686599944,"request_tps":1.8789483560332818,"input_tps":7696.172466312322,"output_tps":1924.0431165780806,"total_tps":9620.215582890403,"mean_input_tokens":4096.0,"mean_output_tokens":1024.0,"ttft_p50_ms":475.5334109941032,"ttft_p95_ms":1353.4896527591625,"ttft_p99_ms":1504.1350853082258,"tpot_p50_ms":15.348146413492753,"tpot_p95_ms":18.516178608853558,"tpot_p99_ms":24.15487474916555,"e2e_p50_ms":16124.824463011464,"e2e_p95_ms":19397.600557809343,"e2e_p99_ms":25655.053696450777,"itl_p50_ms":86.12096303841099,"itl_p95_ms":105.13739398447797,"itl_p99_ms":445.6705811142456,"validation_errors":[],"timestamp":"2026-07-18T08:38:22+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":1024,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":52.432352,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c32_i4096_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c32_i4096_o1024_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":86.8519939740072,"request_tps":2.763321704183631,"input_tps":11318.565700336152,"output_tps":2829.641425084038,"total_tps":14148.20712542019,"mean_input_tokens":4096.0,"mean_output_tokens":1024.0,"ttft_p50_ms":686.349789990345,"ttft_p95_ms":2551.0189717897447,"ttft_p99_ms":2565.8262570202346,"tpot_p50_ms":16.03454321408112,"tpot_p95_ms":20.537836716764918,"tpot_p99_ms":22.564375079230096,"e2e_p50_ms":17469.590187480208,"e2e_p95_ms":22305.416079200222,"e2e_p99_ms":23569.44244973478,"itl_p50_ms":83.71159349917434,"itl_p95_ms":240.308934749919,"itl_p99_ms":477.5934990728274,"validation_errors":[],"timestamp":"2026-07-18T08:40:29+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":1024,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":47.067464,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c48_i4096_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c48_i4096_o1024_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":94.12055041798158,"request_tps":3.3998951193857927,"input_tps":13925.970409004207,"output_tps":3481.4926022510517,"total_tps":17407.46301125526,"mean_input_tokens":4096.0,"mean_output_tokens":1024.0,"ttft_p50_ms":830.0491840054747,"ttft_p95_ms":2979.723842756357,"ttft_p99_ms":3750.8296984556364,"tpot_p50_ms":15.136148952561516,"tpot_p95_ms":25.434608260702316,"tpot_p99_ms":28.41849224315262,"e2e_p50_ms":16605.287618003786,"e2e_p95_ms":26591.6289480374,"e2e_p99_ms":30167.544829621915,"itl_p50_ms":46.78292397875339,"itl_p95_ms":441.8586840038188,"itl_p99_ms":559.7159582073801,"validation_errors":[],"timestamp":"2026-07-18T08:42:51+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":1024,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":23.036529,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c64_i4096_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c64_i4096_o1024_a1.log"} +{"status":"COMPLETED","completed":400,"failed":0,"duration_s":114.97225457796594,"request_tps":3.479100253085397,"input_tps":14250.394636637786,"output_tps":3562.5986591594465,"total_tps":17812.993295797234,"mean_input_tokens":4096.0,"mean_output_tokens":1024.0,"ttft_p50_ms":1086.6218949959148,"ttft_p95_ms":3292.698348281556,"ttft_p99_ms":3350.0421036872985,"tpot_p50_ms":21.075327164720644,"tpot_p95_ms":27.786143711986693,"tpot_p99_ms":33.27980504202292,"e2e_p50_ms":22416.871847963193,"e2e_p95_ms":29478.619533518202,"e2e_p99_ms":34333.9411099354,"itl_p50_ms":85.89501152164303,"itl_p95_ms":455.25294802500866,"itl_p99_ms":757.1816769649739,"validation_errors":[],"timestamp":"2026-07-18T08:45:29+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":1024,"concurrency":80,"num_prompts":400,"warmup_requests":80,"attempt":1,"gain_pct":2.329635,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c80_i4096_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c80_i4096_o1024_a1.log"} +{"status":"COMPLETED","completed":480,"failed":0,"duration_s":157.7628451580531,"request_tps":3.0425414774886756,"input_tps":12462.249891793615,"output_tps":3115.562472948404,"total_tps":15577.812364742018,"mean_input_tokens":4096.0,"mean_output_tokens":1024.0,"ttft_p50_ms":1558.7837230123114,"ttft_p95_ms":5275.506135969771,"ttft_p99_ms":5485.990310001055,"tpot_p50_ms":27.392091055731594,"tpot_p95_ms":41.30529913418748,"tpot_p99_ms":48.123890492433034,"e2e_p50_ms":30063.07220950839,"e2e_p95_ms":43648.297926937805,"e2e_p99_ms":51850.85524753375,"itl_p50_ms":86.38396649621427,"itl_p95_ms":569.8066122015009,"itl_p99_ms":855.9517555573257,"validation_errors":[],"timestamp":"2026-07-18T08:48:55+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":1024,"concurrency":96,"num_prompts":480,"warmup_requests":96,"attempt":1,"gain_pct":-12.548037,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c96_i4096_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c96_i4096_o1024_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":139.6200616019778,"request_tps":0.5729835604002251,"input_tps":2346.940663399322,"output_tps":1173.470331699661,"total_tps":3520.410995098983,"mean_input_tokens":4096.0,"mean_output_tokens":2048.0,"ttft_p50_ms":551.7802540271077,"ttft_p95_ms":1822.2526348690735,"ttft_p99_ms":1860.5395004362792,"tpot_p50_ms":14.539573191510765,"tpot_p95_ms":17.563040948069247,"tpot_p99_ms":18.649929094885096,"e2e_p50_ms":30552.818569994997,"e2e_p95_ms":36796.09513131436,"e2e_p99_ms":38821.86843297386,"itl_p50_ms":86.0036609810777,"itl_p95_ms":90.0370318617206,"itl_p99_ms":403.6393381352536,"validation_errors":[],"timestamp":"2026-07-18T08:51:57+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":2048,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c16_i4096_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c16_i4096_o2048_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":153.51616188703338,"request_tps":1.042235540761746,"input_tps":4268.996774960112,"output_tps":2134.498387480056,"total_tps":6403.495162440168,"mean_input_tokens":4096.0,"mean_output_tokens":2048.0,"ttft_p50_ms":616.2509830028284,"ttft_p95_ms":1821.4225291769176,"ttft_p99_ms":2277.466938588186,"tpot_p50_ms":15.116453714706628,"tpot_p95_ms":17.878458143417664,"tpot_p99_ms":19.371058153620158,"e2e_p50_ms":31893.953127000714,"e2e_p95_ms":37648.02529696026,"e2e_p99_ms":40064.56502196553,"itl_p50_ms":85.33490699483082,"itl_p95_ms":95.79770440468565,"itl_p99_ms":442.66776794334874,"validation_errors":[],"timestamp":"2026-07-18T08:55:13+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":2048,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":81.896238,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c32_i4096_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c32_i4096_o2048_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":156.96399576799013,"request_tps":1.5290130633189674,"input_tps":6262.83750735449,"output_tps":3131.418753677245,"total_tps":9394.256261031735,"mean_input_tokens":4096.0,"mean_output_tokens":2048.0,"ttft_p50_ms":763.7325095420238,"ttft_p95_ms":3268.7599840544863,"ttft_p99_ms":4049.9314173555467,"tpot_p50_ms":14.166230860525223,"tpot_p95_ms":20.299522939336477,"tpot_p99_ms":22.025181064963416,"e2e_p50_ms":29922.516776510747,"e2e_p95_ms":43271.28103052382,"e2e_p99_ms":46021.60174980759,"itl_p50_ms":42.82289301045239,"itl_p95_ms":216.5611038653878,"itl_p99_ms":469.8534761712653,"validation_errors":[],"timestamp":"2026-07-18T08:58:38+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":2048,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":46.705136,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c48_i4096_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c48_i4096_o2048_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":175.3599601489841,"request_tps":1.8248179329427945,"input_tps":7474.454253333686,"output_tps":3737.227126666843,"total_tps":11211.68138000053,"mean_input_tokens":4096.0,"mean_output_tokens":2048.0,"ttft_p50_ms":933.2706205022987,"ttft_p95_ms":4518.157315938151,"ttft_p99_ms":6446.958309601179,"tpot_p50_ms":16.161610005374744,"tpot_p95_ms":22.055725123362254,"tpot_p99_ms":23.649701285718816,"e2e_p50_ms":34222.237945505185,"e2e_p95_ms":45521.83788076509,"e2e_p99_ms":49230.99965577538,"itl_p50_ms":46.56599496956915,"itl_p95_ms":441.2095020175911,"itl_p99_ms":491.9505427614767,"validation_errors":[],"timestamp":"2026-07-18T09:02:14+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":2048,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":19.346131,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c64_i4096_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c64_i4096_o2048_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":266.96818134502973,"request_tps":0.2996611790848887,"input_tps":1227.4121895317041,"output_tps":1227.4121895317041,"total_tps":2454.8243790634083,"mean_input_tokens":4096.0,"mean_output_tokens":4096.0,"ttft_p50_ms":572.6376155216713,"ttft_p95_ms":1799.900960776722,"ttft_p99_ms":1814.4058634620158,"tpot_p50_ms":13.799835589746474,"tpot_p95_ms":16.186108723954014,"tpot_p99_ms":18.752927860861554,"e2e_p50_ms":57481.65439252625,"e2e_p95_ms":67449.03568008449,"e2e_p99_ms":77029.62301582377,"itl_p50_ms":85.98638998228125,"itl_p95_ms":89.346381573705,"itl_p99_ms":183.02164360473273,"validation_errors":[],"timestamp":"2026-07-18T09:07:26+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":4096,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c16_i4096_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c16_i4096_o4096_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":248.48029538500123,"request_tps":0.6439142377551195,"input_tps":2637.4727178449693,"output_tps":2637.4727178449693,"total_tps":5274.945435689939,"mean_input_tokens":4096.0,"mean_output_tokens":4096.0,"ttft_p50_ms":537.7213769825175,"ttft_p95_ms":1873.7105775246164,"ttft_p99_ms":1901.3589589920593,"tpot_p50_ms":13.651357180948093,"tpot_p95_ms":16.539103615101112,"tpot_p99_ms":17.371315408369977,"e2e_p50_ms":56296.214442991186,"e2e_p95_ms":68287.92607152136,"e2e_p99_ms":71486.33029103745,"itl_p50_ms":83.13814550638199,"itl_p95_ms":89.66250361991113,"itl_p99_ms":430.9380889352181,"validation_errors":[],"timestamp":"2026-07-18T09:12:15+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":4096,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":114.880766,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c32_i4096_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c32_i4096_o4096_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":292.01275504601654,"request_tps":0.8218819070495049,"input_tps":3366.428291274772,"output_tps":3366.428291274772,"total_tps":6732.856582549544,"mean_input_tokens":4096.0,"mean_output_tokens":4096.0,"ttft_p50_ms":627.5468615349382,"ttft_p95_ms":3406.3078953389777,"ttft_p99_ms":4043.501213933341,"tpot_p50_ms":15.694712113919671,"tpot_p95_ms":18.550563174786305,"tpot_p99_ms":19.420202869817725,"e2e_p50_ms":64702.450590528315,"e2e_p95_ms":76571.57682245597,"e2e_p99_ms":80068.95612607941,"itl_p50_ms":83.65659200353548,"itl_p95_ms":93.60661054961383,"itl_p99_ms":444.465752437827,"validation_errors":[],"timestamp":"2026-07-18T09:17:52+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":4096,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":27.638412,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c48_i4096_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c48_i4096_o4096_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":311.8440623420174,"request_tps":1.026153897549723,"input_tps":4203.126364363666,"output_tps":4203.126364363666,"total_tps":8406.252728727331,"mean_input_tokens":4096.0,"mean_output_tokens":4096.0,"ttft_p50_ms":923.172466980759,"ttft_p95_ms":4072.749724896857,"ttft_p99_ms":5061.331424221862,"tpot_p50_ms":14.20210784615867,"tpot_p95_ms":18.38619887938988,"tpot_p99_ms":19.913690782330363,"e2e_p50_ms":58716.564560483675,"e2e_p95_ms":77419.06321424467,"e2e_p99_ms":84657.04936399008,"itl_p50_ms":48.455299984198064,"itl_p95_ms":113.22489330195818,"itl_p99_ms":453.62484795856284,"validation_errors":[],"timestamp":"2026-07-18T09:23:47+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":4096,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":24.854178,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c64_i4096_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c64_i4096_o4096_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":29.614950991002843,"request_tps":2.7013382539212833,"input_tps":22129.362976123153,"output_tps":345.77129650192427,"total_tps":22475.134272625077,"mean_input_tokens":8192.0,"mean_output_tokens":128.0,"ttft_p50_ms":2784.4362714968156,"ttft_p95_ms":5191.851028148085,"ttft_p99_ms":5591.543674147103,"tpot_p50_ms":21.974923566953596,"tpot_p95_ms":43.584242678159384,"tpot_p99_ms":52.201654957446955,"e2e_p50_ms":5849.849943013396,"e2e_p95_ms":7828.424685753998,"e2e_p99_ms":8806.173486431362,"itl_p50_ms":42.845841991947964,"itl_p95_ms":835.6105935235973,"itl_p99_ms":1147.399527567904,"validation_errors":[],"timestamp":"2026-07-18T09:24:57+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":8192,"osl":128,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c16_i8192_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c16_i8192_o128_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":19.45748448302038,"request_tps":2.0557641988565427,"input_tps":16840.820317032798,"output_tps":263.13781745363747,"total_tps":17103.958134486435,"mean_input_tokens":8192.0,"mean_output_tokens":128.0,"ttft_p50_ms":2371.3558515300974,"ttft_p95_ms":3324.1320524248295,"ttft_p99_ms":3495.133135763462,"tpot_p50_ms":11.895144062884901,"tpot_p95_ms":27.412530260598725,"tpot_p99_ms":30.372700431355728,"e2e_p50_ms":3783.813933492638,"e2e_p95_ms":5890.503437790903,"e2e_p99_ms":6394.090559320174,"itl_p50_ms":20.66872298019007,"itl_p95_ms":236.6118659847416,"itl_p99_ms":944.3741248105653,"validation_errors":[],"timestamp":"2026-07-18T09:25:56+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":8192,"osl":128,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c8_i8192_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c8_i8192_o128_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":39.48721771495184,"request_tps":2.02597206461847,"input_tps":16596.763153354506,"output_tps":518.6488485423283,"total_tps":17115.412001896835,"mean_input_tokens":8192.0,"mean_output_tokens":256.0,"ttft_p50_ms":1905.3307669819333,"ttft_p95_ms":3478.9570681779874,"ttft_p99_ms":4423.881734638125,"tpot_p50_ms":22.185411870675892,"tpot_p95_ms":38.75998097363466,"tpot_p99_ms":45.74409104169656,"e2e_p50_ms":7661.770432518097,"e2e_p95_ms":12149.851308899813,"e2e_p99_ms":13442.629643468532,"itl_p50_ms":86.74416498979554,"itl_p95_ms":753.5237190313636,"itl_p99_ms":972.144412831403,"validation_errors":[],"timestamp":"2026-07-18T09:27:17+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":8192,"osl":256,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c16_i8192_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c16_i8192_o256_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":59.970154131995514,"request_tps":2.667993809851427,"input_tps":21856.20529030289,"output_tps":683.0064153219653,"total_tps":22539.211705624853,"mean_input_tokens":8192.0,"mean_output_tokens":256.0,"ttft_p50_ms":2947.5211384997237,"ttft_p95_ms":4964.0769181976775,"ttft_p99_ms":5743.8776902284,"tpot_p50_ms":35.03390112732008,"tpot_p95_ms":63.62700134909519,"tpot_p99_ms":74.63737703087813,"e2e_p50_ms":11047.260121471481,"e2e_p95_ms":18929.78601059875,"e2e_p99_ms":23294.713307859492,"itl_p50_ms":88.06432949495502,"itl_p95_ms":952.0654192456277,"itl_p99_ms":1141.3550618424779,"validation_errors":[],"timestamp":"2026-07-18T09:28:57+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":8192,"osl":256,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":31.689566,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c32_i8192_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c32_i8192_o256_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":44.58268308202969,"request_tps":1.7944186950974752,"input_tps":14699.877950238517,"output_tps":918.7423718899073,"total_tps":15618.620322128425,"mean_input_tokens":8192.0,"mean_output_tokens":512.0,"ttft_p50_ms":1167.9714444908313,"ttft_p95_ms":3001.0098257829654,"ttft_p99_ms":4263.851331711628,"tpot_p50_ms":13.396330834642042,"tpot_p95_ms":21.666783544609917,"tpot_p99_ms":24.48126724741645,"e2e_p50_ms":8840.341238013934,"e2e_p95_ms":11806.007072265493,"e2e_p99_ms":14434.372672879832,"itl_p50_ms":27.73381699807942,"itl_p95_ms":197.79930661898092,"itl_p99_ms":774.2122251470571,"validation_errors":[],"timestamp":"2026-07-18T09:30:26+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":8192,"osl":512,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c16_i8192_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c16_i8192_o512_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":78.43856221396709,"request_tps":2.0398130139553956,"input_tps":16710.1482103226,"output_tps":1044.3842631451625,"total_tps":17754.532473467763,"mean_input_tokens":8192.0,"mean_output_tokens":512.0,"ttft_p50_ms":1981.0228349815588,"ttft_p95_ms":3132.4513779691156,"ttft_p99_ms":4200.387257434195,"tpot_p50_ms":26.91621159495186,"tpot_p95_ms":39.9750964151713,"tpot_p99_ms":44.11276608237809,"e2e_p50_ms":15605.310749466298,"e2e_p95_ms":22435.930335614827,"e2e_p99_ms":23594.96351189562,"itl_p50_ms":89.27572396351025,"itl_p95_ms":774.3357784987892,"itl_p99_ms":947.5925189442933,"validation_errors":[],"timestamp":"2026-07-18T09:32:26+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":8192,"osl":512,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":13.675421,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c32_i8192_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c32_i8192_o512_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":111.76454624795588,"request_tps":2.147371488159999,"input_tps":17591.26723100671,"output_tps":1099.4542019379194,"total_tps":18690.72143294463,"mean_input_tokens":8192.0,"mean_output_tokens":512.0,"ttft_p50_ms":3317.045703966869,"ttft_p95_ms":5305.585861799773,"ttft_p99_ms":6343.802231333683,"tpot_p50_ms":36.9875732759299,"tpot_p95_ms":60.41191455044915,"tpot_p99_ms":65.82440484550375,"e2e_p50_ms":22271.335786004784,"e2e_p95_ms":34000.34795922692,"e2e_p99_ms":37064.025816970934,"itl_p50_ms":82.6910919859074,"itl_p95_ms":943.0376058095134,"itl_p99_ms":1137.9081320803382,"validation_errors":[],"timestamp":"2026-07-18T09:34:58+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":8192,"osl":512,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":5.272958,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c48_i8192_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c48_i8192_o512_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":63.63868967798771,"request_tps":1.2570969076327727,"input_tps":10298.137867327674,"output_tps":1287.2672334159593,"total_tps":11585.405100743632,"mean_input_tokens":8192.0,"mean_output_tokens":1024.0,"ttft_p50_ms":969.3201749760192,"ttft_p95_ms":1666.0242232115702,"ttft_p99_ms":1877.875963253899,"tpot_p50_ms":8.88615048779284,"tpot_p95_ms":18.722103676035065,"tpot_p99_ms":19.89444449977238,"e2e_p50_ms":9838.224477512995,"e2e_p95_ms":20148.284135680296,"e2e_p99_ms":20996.64813029987,"itl_p50_ms":27.12986001279205,"itl_p95_ms":93.19167949142866,"itl_p99_ms":266.09184819040814,"validation_errors":[],"timestamp":"2026-07-18T09:36:46+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":8192,"osl":1024,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c16_i8192_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c16_i8192_o1024_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":83.21440474601695,"request_tps":1.9227440307762147,"input_tps":15751.11910011875,"output_tps":1968.8898875148438,"total_tps":17720.008987633595,"mean_input_tokens":8192.0,"mean_output_tokens":1024.0,"ttft_p50_ms":1083.2168874621857,"ttft_p95_ms":3174.1375397803495,"ttft_p99_ms":4035.124112702905,"tpot_p50_ms":13.75796393598184,"tpot_p95_ms":25.268526618448696,"tpot_p99_ms":27.856793439931593,"e2e_p50_ms":15130.157069535926,"e2e_p95_ms":27004.053745701083,"e2e_p99_ms":29551.686298057903,"itl_p50_ms":31.62436603452079,"itl_p95_ms":208.74238923715893,"itl_p99_ms":775.0866257050075,"validation_errors":[],"timestamp":"2026-07-18T09:38:49+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":8192,"osl":1024,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":52.951138,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c32_i8192_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c32_i8192_o1024_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":131.83825000398792,"request_tps":1.8204125130054467,"input_tps":14912.81930654062,"output_tps":1864.1024133175774,"total_tps":16776.921719858197,"mean_input_tokens":8192.0,"mean_output_tokens":1024.0,"ttft_p50_ms":1637.9205574921798,"ttft_p95_ms":3403.0644794867803,"ttft_p99_ms":3997.1313432877623,"tpot_p50_ms":23.278314838207983,"tpot_p95_ms":35.56336575878325,"tpot_p99_ms":42.15927951784623,"e2e_p50_ms":25257.49702102621,"e2e_p95_ms":37540.11986076366,"e2e_p99_ms":44867.04239854003,"itl_p50_ms":85.25513400672935,"itl_p95_ms":767.4715867324267,"itl_p99_ms":796.2605234904912,"validation_errors":[],"timestamp":"2026-07-18T09:41:46+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":8192,"osl":1024,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":-5.32216,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c48_i8192_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c48_i8192_o1024_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":172.50034251599573,"request_tps":1.8550687803435917,"input_tps":15196.723448574703,"output_tps":1899.5904310718379,"total_tps":17096.31387964654,"mean_input_tokens":8192.0,"mean_output_tokens":1024.0,"ttft_p50_ms":2321.7819970159326,"ttft_p95_ms":5701.194877337549,"ttft_p99_ms":6436.547990816762,"tpot_p50_ms":30.75758299853708,"tpot_p95_ms":49.72987918850974,"tpot_p99_ms":54.9858482532205,"e2e_p50_ms":33388.969735009596,"e2e_p95_ms":52575.173008479775,"e2e_p99_ms":59077.59353278729,"itl_p50_ms":85.58061148505658,"itl_p95_ms":787.0776694646338,"itl_p99_ms":962.1273954201021,"validation_errors":[],"timestamp":"2026-07-18T09:45:26+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":8192,"osl":1024,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":1.903759,"plateau_streak":2,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c64_i8192_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c64_i8192_o1024_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":166.06670837197453,"request_tps":0.48173412229504287,"input_tps":3946.365929840991,"output_tps":986.5914824602478,"total_tps":4932.957412301239,"mean_input_tokens":8192.0,"mean_output_tokens":2048.0,"ttft_p50_ms":437.99855999532156,"ttft_p95_ms":2884.1156758891884,"ttft_p99_ms":3689.9406695942143,"tpot_p50_ms":15.669278370783038,"tpot_p95_ms":18.6107645438377,"tpot_p99_ms":19.49036785215349,"e2e_p50_ms":33265.59404749423,"e2e_p95_ms":39526.65018734406,"e2e_p99_ms":40540.58274070032,"itl_p50_ms":87.75097300531343,"itl_p95_ms":91.46166910650209,"itl_p99_ms":247.54982748127074,"validation_errors":[],"timestamp":"2026-07-18T09:48:54+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":8192,"osl":2048,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c16_i8192_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c16_i8192_o2048_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":165.60577887797263,"request_tps":0.9661498595281311,"input_tps":7914.69964925445,"output_tps":1978.6749123136126,"total_tps":9893.374561568064,"mean_input_tokens":8192.0,"mean_output_tokens":2048.0,"ttft_p50_ms":1039.7498829988763,"ttft_p95_ms":4501.546557818074,"ttft_p99_ms":4856.566047638771,"tpot_p50_ms":15.60548643476528,"tpot_p95_ms":19.74559658329187,"tpot_p99_ms":21.41375453154922,"e2e_p50_ms":33757.71594501566,"e2e_p95_ms":41949.21424889762,"e2e_p99_ms":46027.005066509,"itl_p50_ms":85.04903997527435,"itl_p95_ms":112.47541246120818,"itl_p99_ms":766.8663851218299,"validation_errors":[],"timestamp":"2026-07-18T09:52:23+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":8192,"osl":2048,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":100.556659,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c32_i8192_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c32_i8192_o2048_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":319.28498376498464,"request_tps":0.2505598573933731,"input_tps":2052.5863517665125,"output_tps":1026.2931758832563,"total_tps":3078.8795276497685,"mean_input_tokens":8192.0,"mean_output_tokens":4096.0,"ttft_p50_ms":956.5684015105944,"ttft_p95_ms":2272.1317229268607,"ttft_p99_ms":2321.48210371146,"tpot_p50_ms":15.355536374360122,"tpot_p95_ms":17.406654515419092,"tpot_p99_ms":18.21259394207226,"e2e_p50_ms":63420.155379979406,"e2e_p95_ms":72865.65650612174,"e2e_p99_ms":74914.94843816267,"itl_p50_ms":87.67799098859541,"itl_p95_ms":92.32483748928644,"itl_p99_ms":227.98387271759512,"validation_errors":[],"timestamp":"2026-07-18T09:58:22+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":8192,"osl":4096,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c16_i8192_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c16_i8192_o4096_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":253.61872760299593,"request_tps":0.6308682387621519,"input_tps":5168.072611939549,"output_tps":2584.0363059697743,"total_tps":7752.108917909322,"mean_input_tokens":8192.0,"mean_output_tokens":4096.0,"ttft_p50_ms":1021.5006909857038,"ttft_p95_ms":3240.4598360823,"ttft_p99_ms":4007.1616849163547,"tpot_p50_ms":11.167135860428946,"tpot_p95_ms":17.77178179756545,"tpot_p99_ms":19.992637108685194,"e2e_p50_ms":47091.64167600102,"e2e_p95_ms":74792.16685414429,"e2e_p99_ms":84594.39204503433,"itl_p50_ms":31.910240009892732,"itl_p95_ms":95.76948165195063,"itl_p99_ms":758.1904256547568,"validation_errors":[],"timestamp":"2026-07-18T10:03:17+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":8192,"osl":4096,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":151.783444,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c32_i8192_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c32_i8192_o4096_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":382.6091681320104,"request_tps":0.6272719526605635,"input_tps":5138.611836195336,"output_tps":2569.305918097668,"total_tps":7707.917754293005,"mean_input_tokens":8192.0,"mean_output_tokens":4096.0,"ttft_p50_ms":1385.3051339974627,"ttft_p95_ms":6189.032332293572,"ttft_p99_ms":8080.3668566275155,"tpot_p50_ms":17.622810712206988,"tpot_p95_ms":21.946539240846608,"tpot_p99_ms":23.050956556077285,"e2e_p50_ms":73827.30599897332,"e2e_p95_ms":91535.29502529418,"e2e_p99_ms":96658.71568659726,"itl_p50_ms":86.69854150502943,"itl_p95_ms":127.61127694975555,"itl_p99_ms":771.6891354462132,"validation_errors":[],"timestamp":"2026-07-18T10:10:27+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":8192,"osl":4096,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":-0.570053,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c48_i8192_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c48_i8192_o4096_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":54.26816228899406,"request_tps":1.4741608454322863,"input_tps":24152.65129156258,"output_tps":188.69258821533265,"total_tps":24341.34387977791,"mean_input_tokens":16384.0,"mean_output_tokens":128.0,"ttft_p50_ms":4936.1393909784965,"ttft_p95_ms":9391.542086238038,"ttft_p99_ms":11954.259529567782,"tpot_p50_ms":43.423500791325885,"tpot_p95_ms":77.21515882317541,"tpot_p99_ms":81.965605701846,"e2e_p50_ms":10794.661530002486,"e2e_p95_ms":14394.403066666562,"e2e_p99_ms":19242.040591037927,"itl_p50_ms":91.46432601846755,"itl_p95_ms":1129.6300308022182,"itl_p99_ms":1263.358361232095,"validation_errors":[],"timestamp":"2026-07-18T10:12:07+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":16384,"osl":128,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c16_i16384_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c16_i16384_o128_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":26.561979502032045,"request_tps":1.505911861611817,"input_tps":24672.85994064801,"output_tps":192.75671828631258,"total_tps":24865.616658934323,"mean_input_tokens":16384.0,"mean_output_tokens":128.0,"ttft_p50_ms":2994.864296517335,"ttft_p95_ms":5198.206618326367,"ttft_p99_ms":5264.80451795971,"tpot_p50_ms":17.47658929932408,"tpot_p95_ms":33.901606895410865,"tpot_p99_ms":38.27727929643157,"e2e_p50_ms":5207.026343996404,"e2e_p95_ms":5892.241225237375,"e2e_p99_ms":6516.694844309241,"itl_p50_ms":21.834292507264763,"itl_p95_ms":777.6870535017224,"itl_p99_ms":968.8869674282614,"validation_errors":[],"timestamp":"2026-07-18T10:13:19+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":16384,"osl":128,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c8_i16384_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c8_i16384_o128_a1.log"} +{"status":"COMPLETED","completed":5,"failed":0,"duration_s":7.423103672044817,"request_tps":0.6735727023225943,"input_tps":11035.815154853384,"output_tps":86.21730589729206,"total_tps":11122.032460750675,"mean_input_tokens":16384.0,"mean_output_tokens":128.0,"ttft_p50_ms":1789.521164027974,"ttft_p95_ms":1829.4172604102641,"ttft_p99_ms":1832.8168233018368,"tpot_p50_ms":2.106206480589673,"tpot_p95_ms":2.9801548201972103,"tpot_p99_ms":3.0631683118582713,"e2e_p50_ms":2054.192903044168,"e2e_p95_ms":2088.6737442109734,"e2e_p99_ms":2090.4269592557102,"itl_p50_ms":12.995131022762507,"itl_p95_ms":16.75838020746596,"itl_p99_ms":17.42097016365733,"validation_errors":[],"timestamp":"2026-07-18T10:14:08+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":16384,"osl":128,"concurrency":1,"num_prompts":5,"warmup_requests":1,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c1_i16384_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c1_i16384_o128_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":57.84803625801578,"request_tps":1.3829337203977206,"input_tps":22657.986074996254,"output_tps":354.03103242181646,"total_tps":23012.01710741807,"mean_input_tokens":16384.0,"mean_output_tokens":256.0,"ttft_p50_ms":4469.155842496548,"ttft_p95_ms":9331.6880250175,"ttft_p99_ms":10563.227438584434,"tpot_p50_ms":26.177785260826532,"tpot_p95_ms":45.88193477683827,"tpot_p99_ms":55.0100964285185,"e2e_p50_ms":11456.093841494294,"e2e_p95_ms":15285.850205406314,"e2e_p99_ms":20393.137551293436,"itl_p50_ms":26.476440485566854,"itl_p95_ms":956.8046340369618,"itl_p99_ms":1165.123563981033,"validation_errors":[],"timestamp":"2026-07-18T10:15:44+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":16384,"osl":256,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c16_i16384_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c16_i16384_o256_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":33.179765445995145,"request_tps":1.2055540315710118,"input_tps":19751.797253259458,"output_tps":308.621832082179,"total_tps":20060.419085341637,"mean_input_tokens":16384.0,"mean_output_tokens":256.0,"ttft_p50_ms":2706.0664060118143,"ttft_p95_ms":6438.790974381842,"ttft_p99_ms":7533.3791601337725,"tpot_p50_ms":13.772414654936169,"tpot_p95_ms":29.071007144589473,"tpot_p99_ms":33.78512353656183,"e2e_p50_ms":6015.991558000678,"e2e_p95_ms":12332.725861997453,"e2e_p99_ms":14488.047595008975,"itl_p50_ms":22.117166023235768,"itl_p95_ms":737.5980248092673,"itl_p99_ms":805.4118642606772,"validation_errors":[],"timestamp":"2026-07-18T10:16:55+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":16384,"osl":256,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c8_i16384_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c8_i16384_o256_a1.log"} +{"status":"COMPLETED","completed":5,"failed":0,"duration_s":5.236904031015001,"request_tps":0.9547625792621055,"input_tps":15642.830098630337,"output_tps":244.419220291099,"total_tps":15887.249318921436,"mean_input_tokens":16384.0,"mean_output_tokens":256.0,"ttft_p50_ms":274.3648120085709,"ttft_p95_ms":285.339293431025,"ttft_p99_ms":287.2778595215641,"tpot_p50_ms":2.965654372511541,"tpot_p95_ms":3.3486706760766753,"tpot_p99_ms":3.420261865390428,"e2e_p50_ms":1029.2242160066962,"e2e_p95_ms":1130.7026147842407,"e2e_p99_ms":1148.0422645341605,"itl_p50_ms":17.808803997468203,"itl_p95_ms":19.162981273257174,"itl_p99_ms":20.505390813341364,"validation_errors":[],"timestamp":"2026-07-18T10:17:49+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":16384,"osl":256,"concurrency":1,"num_prompts":5,"warmup_requests":1,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c1_i16384_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c1_i16384_o256_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":69.5219704299816,"request_tps":1.1507153710577185,"input_tps":18853.32063940966,"output_tps":589.1662699815519,"total_tps":19442.486909391213,"mean_input_tokens":16384.0,"mean_output_tokens":512.0,"ttft_p50_ms":2076.1385314981453,"ttft_p95_ms":5125.922045714104,"ttft_p99_ms":6313.240676054846,"tpot_p50_ms":20.886728227040102,"tpot_p95_ms":36.59230016733847,"tpot_p99_ms":42.50432928451585,"e2e_p50_ms":13437.82597250538,"e2e_p95_ms":21968.160882755183,"e2e_p99_ms":25817.890475417924,"itl_p50_ms":86.38499700464308,"itl_p95_ms":775.1364229712635,"itl_p99_ms":840.8635402005166,"validation_errors":[],"timestamp":"2026-07-18T10:19:42+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":16384,"osl":512,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c16_i16384_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c16_i16384_o512_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":36.274343941011466,"request_tps":1.1027077447643743,"input_tps":18066.763690219508,"output_tps":564.5863653193596,"total_tps":18631.350055538867,"mean_input_tokens":16384.0,"mean_output_tokens":512.0,"ttft_p50_ms":1819.3785594776273,"ttft_p95_ms":2914.974233604151,"ttft_p99_ms":3800.43408610567,"tpot_p50_ms":10.224514226009978,"tpot_p95_ms":18.749744540598478,"tpot_p99_ms":21.752845666658565,"e2e_p50_ms":6722.872220008867,"e2e_p95_ms":11944.418152060825,"e2e_p99_ms":12524.898428966408,"itl_p50_ms":21.45599899813533,"itl_p95_ms":144.04231251683086,"itl_p99_ms":782.6593501260505,"validation_errors":[],"timestamp":"2026-07-18T10:21:02+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":16384,"osl":512,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c8_i16384_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c8_i16384_o512_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":80.37557773501612,"request_tps":0.9953272157339343,"input_tps":16307.44110258478,"output_tps":1019.2150689115488,"total_tps":17326.656171496328,"mean_input_tokens":16384.0,"mean_output_tokens":1024.0,"ttft_p50_ms":1382.8448979766108,"ttft_p95_ms":3386.1308315041238,"ttft_p99_ms":3492.6950885675615,"tpot_p50_ms":14.78877704152892,"tpot_p95_ms":20.250942600727235,"tpot_p99_ms":23.958961475818718,"e2e_p50_ms":16791.32158498396,"e2e_p95_ms":21982.93933319801,"e2e_p99_ms":25310.551779199115,"itl_p50_ms":22.69656799035147,"itl_p95_ms":178.4113619942218,"itl_p99_ms":781.2623753794469,"validation_errors":[],"timestamp":"2026-07-18T10:23:03+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":16384,"osl":1024,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c16_i16384_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c16_i16384_o1024_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":167.13706241402542,"request_tps":0.9572981461386119,"input_tps":15684.372826335017,"output_tps":980.2733016459385,"total_tps":16664.646127980955,"mean_input_tokens":16384.0,"mean_output_tokens":1024.0,"ttft_p50_ms":3251.3440039765555,"ttft_p95_ms":6952.165713196155,"ttft_p99_ms":7870.555638762888,"tpot_p50_ms":28.913829782497473,"tpot_p95_ms":52.91921035537402,"tpot_p99_ms":58.08397062838213,"e2e_p50_ms":32264.607000513934,"e2e_p95_ms":59142.48431767625,"e2e_p99_ms":63568.682242943316,"itl_p50_ms":34.45855397148989,"itl_p95_ms":798.5008348739938,"itl_p99_ms":1029.0564740169793,"validation_errors":[],"timestamp":"2026-07-18T10:26:36+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":16384,"osl":1024,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":-3.820761,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c32_i16384_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c32_i16384_o1024_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":105.69097364798654,"request_tps":0.7569236732215877,"input_tps":12401.437462062493,"output_tps":1550.1796827578116,"total_tps":13951.617144820304,"mean_input_tokens":16384.0,"mean_output_tokens":2048.0,"ttft_p50_ms":1071.806699008448,"ttft_p95_ms":2664.9833560484694,"ttft_p99_ms":3713.0523588438514,"tpot_p50_ms":7.906581123105742,"tpot_p95_ms":18.591349791894025,"tpot_p99_ms":21.992429177424132,"e2e_p50_ms":17490.298040007474,"e2e_p95_ms":40915.38965998334,"e2e_p99_ms":47244.787441137574,"itl_p50_ms":22.41447602864355,"itl_p95_ms":93.97252242779359,"itl_p99_ms":761.0243633796927,"validation_errors":[],"timestamp":"2026-07-18T10:29:07+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":16384,"osl":2048,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c16_i16384_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c16_i16384_o2048_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":217.20543494197773,"request_tps":0.7366298179543295,"input_tps":12068.942937363734,"output_tps":1508.6178671704668,"total_tps":13577.5608045342,"mean_input_tokens":16384.0,"mean_output_tokens":2048.0,"ttft_p50_ms":2319.4135829689912,"ttft_p95_ms":4362.745253514731,"ttft_p99_ms":5427.9249174206,"tpot_p50_ms":19.7755500082958,"tpot_p95_ms":27.721301956710715,"tpot_p99_ms":28.93322430962401,"e2e_p50_ms":43255.36743950215,"e2e_p95_ms":57763.0944744218,"e2e_p99_ms":61743.36161403102,"itl_p50_ms":85.93565950286575,"itl_p95_ms":755.4431096301413,"itl_p99_ms":806.8811128719244,"validation_errors":[],"timestamp":"2026-07-18T10:33:30+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":16384,"osl":2048,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":-2.681097,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c32_i16384_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c32_i16384_o2048_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":109.53005035000388,"request_tps":0.7303931637423663,"input_tps":23933.52318950986,"output_tps":93.49032495902289,"total_tps":24027.01351446888,"mean_input_tokens":32768.0,"mean_output_tokens":128.0,"ttft_p50_ms":8297.30045600445,"ttft_p95_ms":19523.505493134133,"ttft_p99_ms":24515.16996988735,"tpot_p50_ms":108.17010097245056,"tpot_p95_ms":163.53306737075297,"tpot_p99_ms":198.5117210431972,"e2e_p50_ms":20521.71137748519,"e2e_p95_ms":36602.358588410425,"e2e_p99_ms":41499.812797436025,"itl_p50_ms":305.3573125216644,"itl_p95_ms":1367.2616182593629,"itl_p99_ms":1403.4266747621587,"validation_errors":[],"timestamp":"2026-07-18T10:36:02+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":32768,"osl":128,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c16_i32768_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c16_i32768_o128_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":67.58772420702735,"request_tps":0.5918234482563188,"input_tps":19392.870752463055,"output_tps":75.75340137680881,"total_tps":19468.624153839864,"mean_input_tokens":32768.0,"mean_output_tokens":128.0,"ttft_p50_ms":7622.563400014769,"ttft_p95_ms":12720.981366332853,"ttft_p99_ms":14194.837554899277,"tpot_p50_ms":43.06288808675879,"tpot_p95_ms":98.09243177264511,"tpot_p99_ms":99.01045506853539,"e2e_p50_ms":13021.875192032894,"e2e_p95_ms":17779.4025837793,"e2e_p99_ms":18113.983492607367,"itl_p50_ms":22.518536454299465,"itl_p95_ms":1020.287898508832,"itl_p99_ms":1216.4375054906122,"validation_errors":[],"timestamp":"2026-07-18T10:37:54+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":32768,"osl":128,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c8_i32768_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c8_i32768_o128_a1.log"} +{"status":"COMPLETED","completed":5,"failed":0,"duration_s":16.428138170042075,"request_tps":0.30435585263812,"input_tps":9973.132579245916,"output_tps":38.95754913767936,"total_tps":10012.090128383596,"mean_input_tokens":32768.0,"mean_output_tokens":128.0,"ttft_p50_ms":3650.388448033482,"ttft_p95_ms":3682.1509984205477,"ttft_p99_ms":3686.88798771007,"tpot_p50_ms":2.192514897672474,"tpot_p95_ms":2.8153047291928623,"tpot_p99_ms":2.932150136518079,"e2e_p50_ms":3905.3959799930453,"e2e_p95_ms":3950.307671027258,"e2e_p99_ms":3953.622142234817,"itl_p50_ms":13.099227478960529,"itl_p95_ms":16.88582348288037,"itl_p99_ms":19.47088856250048,"validation_errors":[],"timestamp":"2026-07-18T10:38:51+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":32768,"osl":128,"concurrency":1,"num_prompts":5,"warmup_requests":1,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c1_i32768_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c1_i32768_o128_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":114.18444471998373,"request_tps":0.7006208262096053,"input_tps":22957.943233236347,"output_tps":179.35893150965896,"total_tps":23137.302164746005,"mean_input_tokens":32768.0,"mean_output_tokens":256.0,"ttft_p50_ms":7379.696910502389,"ttft_p95_ms":15462.661365079111,"ttft_p99_ms":21105.341926106466,"tpot_p50_ms":59.492727158837674,"tpot_p95_ms":95.95281595562803,"tpot_p99_ms":113.91104273594595,"e2e_p50_ms":22532.36136000487,"e2e_p95_ms":33678.95815256051,"e2e_p99_ms":42771.73485785834,"itl_p50_ms":86.65077251498587,"itl_p95_ms":1195.885096339043,"itl_p99_ms":1345.8398182416568,"validation_errors":[],"timestamp":"2026-07-18T10:41:36+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":32768,"osl":256,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c16_i32768_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c16_i32768_o256_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":41.599180418998,"request_tps":0.9615574056293746,"input_tps":31508.31306766335,"output_tps":246.1586958411199,"total_tps":31754.471763504465,"mean_input_tokens":32768.0,"mean_output_tokens":256.0,"ttft_p50_ms":4706.275655480567,"ttft_p95_ms":8816.404092166338,"ttft_p99_ms":9152.687992039137,"tpot_p50_ms":17.25038480579707,"tpot_p95_ms":30.43335540762271,"tpot_p99_ms":32.247571870684624,"e2e_p50_ms":8153.937003517058,"e2e_p95_ms":10342.26786622894,"e2e_p99_ms":10883.75198687776,"itl_p50_ms":22.443900990765542,"itl_p95_ms":807.699972006958,"itl_p99_ms":1022.0545367803425,"validation_errors":[],"timestamp":"2026-07-18T10:43:00+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":32768,"osl":256,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c8_i32768_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c8_i32768_o256_a1.log"} +{"status":"COMPLETED","completed":5,"failed":0,"duration_s":11.614725697960239,"request_tps":0.4304879968777991,"input_tps":14106.23068169172,"output_tps":110.20492720071657,"total_tps":14216.435608892436,"mean_input_tokens":32768.0,"mean_output_tokens":256.0,"ttft_p50_ms":370.73185900226235,"ttft_p95_ms":3687.4129599775188,"ttft_p99_ms":3691.4805751736276,"tpot_p50_ms":2.47625407041507,"tpot_p95_ms":3.0247205200459004,"tpot_p99_ms":3.113214406796603,"e2e_p50_ms":1143.6590710072778,"e2e_p95_ms":4250.90667278273,"e2e_p99_ms":4256.920696140733,"itl_p50_ms":14.952550001908094,"itl_p95_ms":16.55674904177431,"itl_p99_ms":16.991753112524744,"validation_errors":[],"timestamp":"2026-07-18T10:43:53+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":32768,"osl":256,"concurrency":1,"num_prompts":5,"warmup_requests":1,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c1_i32768_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c1_i32768_o256_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":123.24822137999581,"request_tps":0.6490965882042713,"input_tps":21269.597002277562,"output_tps":332.3374531605869,"total_tps":21601.934455438146,"mean_input_tokens":32768.0,"mean_output_tokens":512.0,"ttft_p50_ms":5958.263435983099,"ttft_p95_ms":13562.941967009101,"ttft_p99_ms":15317.145432657542,"tpot_p50_ms":34.616514187843364,"tpot_p95_ms":57.214765334873206,"tpot_p99_ms":70.9911398787322,"e2e_p50_ms":25784.815993509255,"e2e_p95_ms":37332.248073621304,"e2e_p99_ms":49905.079117035995,"itl_p50_ms":87.44556951569393,"itl_p95_ms":1010.8573953359155,"itl_p99_ms":1218.3430715167194,"validation_errors":[],"timestamp":"2026-07-18T10:46:32+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":32768,"osl":512,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c16_i32768_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c16_i32768_o512_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":62.43291814700933,"request_tps":0.6406876562427042,"input_tps":20994.05311976093,"output_tps":328.03207999626454,"total_tps":21322.085199757195,"mean_input_tokens":32768.0,"mean_output_tokens":512.0,"ttft_p50_ms":3715.485319000436,"ttft_p95_ms":10494.657049843227,"ttft_p99_ms":10504.53708427609,"tpot_p50_ms":15.538270226025903,"tpot_p95_ms":27.201843363189163,"tpot_p99_ms":31.217008260812985,"e2e_p50_ms":11462.35631647869,"e2e_p95_ms":16725.083480897585,"e2e_p99_ms":20437.961967124134,"itl_p50_ms":21.51713753119111,"itl_p95_ms":796.4354616065975,"itl_p99_ms":1023.8810452696632,"validation_errors":[],"timestamp":"2026-07-18T10:48:14+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":32768,"osl":512,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c8_i32768_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c8_i32768_o512_a1.log"} +{"status":"COMPLETED","completed":5,"failed":0,"duration_s":8.054679996042978,"request_tps":0.6207571253552406,"input_tps":20340.969483640525,"output_tps":317.8276481818832,"total_tps":20658.797131822408,"mean_input_tokens":32768.0,"mean_output_tokens":512.0,"ttft_p50_ms":334.58302303915843,"ttft_p95_ms":344.42229338455945,"ttft_p99_ms":344.72759226802737,"tpot_p50_ms":2.380267894301024,"tpot_p95_ms":2.881846670015786,"tpot_p99_ms":2.962525069372776,"e2e_p50_ms":1550.663786008954,"e2e_p95_ms":1808.8692266028374,"e2e_p99_ms":1848.7658445257694,"itl_p50_ms":14.42336302716285,"itl_p95_ms":16.133033810183406,"itl_p99_ms":16.646274684462693,"validation_errors":[],"timestamp":"2026-07-18T10:49:00+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":32768,"osl":512,"concurrency":1,"num_prompts":5,"warmup_requests":1,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c1_i32768_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c1_i32768_o512_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":169.31001793796895,"request_tps":0.4725060039229932,"input_tps":15483.07673654864,"output_tps":483.846148017145,"total_tps":15966.922884565785,"mean_input_tokens":32768.0,"mean_output_tokens":1024.0,"ttft_p50_ms":5664.147588977357,"ttft_p95_ms":12599.152948398836,"ttft_p99_ms":15932.982259468408,"tpot_p50_ms":27.41253739736682,"tpot_p95_ms":47.65939222007089,"tpot_p99_ms":54.193455567944156,"e2e_p50_ms":33423.35990598076,"e2e_p95_ms":55132.7489905263,"e2e_p99_ms":61559.99458893201,"itl_p50_ms":26.94829151732847,"itl_p95_ms":839.0516332583502,"itl_p99_ms":1095.6323972466635,"validation_errors":[],"timestamp":"2026-07-18T10:52:30+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":32768,"osl":1024,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c16_i32768_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c16_i32768_o1024_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":84.46462155104382,"request_tps":0.4735710557328091,"input_tps":15517.976354252689,"output_tps":484.9367610703965,"total_tps":16002.913115323085,"mean_input_tokens":32768.0,"mean_output_tokens":1024.0,"ttft_p50_ms":4107.496461016126,"ttft_p95_ms":8164.71522978099,"ttft_p99_ms":10040.1624987385,"tpot_p50_ms":12.990836584043826,"tpot_p95_ms":18.965096888630256,"tpot_p99_ms":22.820904410111567,"e2e_p50_ms":17678.854117024457,"e2e_p95_ms":22364.361823716896,"e2e_p99_ms":25344.83961896971,"itl_p50_ms":18.67389603285119,"itl_p95_ms":751.2917849817313,"itl_p99_ms":937.1386725921184,"validation_errors":[],"timestamp":"2026-07-18T10:54:34+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":32768,"osl":1024,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c8_i32768_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c8_i32768_o1024_a1.log"} +{"status":"COMPLETED","completed":5,"failed":0,"duration_s":20.059558195003774,"request_tps":0.24925773296668857,"input_tps":8167.677393852451,"output_tps":255.2399185578891,"total_tps":8422.91731241034,"mean_input_tokens":32768.0,"mean_output_tokens":1024.0,"ttft_p50_ms":371.4449259568937,"ttft_p95_ms":3035.6526602292424,"ttft_p99_ms":3563.628674470819,"tpot_p50_ms":2.8563003030260576,"tpot_p95_ms":3.361603734675223,"tpot_p99_ms":3.4327798397785534,"e2e_p50_ms":3437.0667379698716,"e2e_p95_ms":5905.517417413648,"e2e_p99_ms":6307.063108298462,"itl_p50_ms":17.418531992007047,"itl_p95_ms":18.515130796004087,"itl_p99_ms":19.440658505773158,"validation_errors":[],"timestamp":"2026-07-18T10:55:38+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":32768,"osl":1024,"concurrency":1,"num_prompts":5,"warmup_requests":1,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c1_i32768_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c1_i32768_o1024_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":225.43298149696784,"request_tps":0.35487265203506185,"input_tps":11628.467061884907,"output_tps":726.7791913678067,"total_tps":12355.246253252713,"mean_input_tokens":32768.0,"mean_output_tokens":2048.0,"ttft_p50_ms":4874.941665009828,"ttft_p95_ms":9083.321337107916,"ttft_p99_ms":9599.46035788394,"tpot_p50_ms":20.211801863211544,"tpot_p95_ms":31.21886773769535,"tpot_p99_ms":34.83563054005826,"e2e_p50_ms":45875.763709511375,"e2e_p95_ms":67900.1025243022,"e2e_p99_ms":73939.74336972048,"itl_p50_ms":26.710387493949383,"itl_p95_ms":781.9491922855377,"itl_p99_ms":1004.4529186969166,"validation_errors":[],"timestamp":"2026-07-18T11:00:06+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":32768,"osl":2048,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c16_i32768_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c16_i32768_o2048_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":106.15509920899058,"request_tps":0.3768071463175863,"input_tps":12347.216570534667,"output_tps":771.7010356584167,"total_tps":13118.917606193083,"mean_input_tokens":32768.0,"mean_output_tokens":2048.0,"ttft_p50_ms":1679.1197349957656,"ttft_p95_ms":4877.943387217237,"ttft_p99_ms":6310.457653792108,"tpot_p50_ms":7.865269762337273,"tpot_p95_ms":19.258896540128138,"tpot_p99_ms":19.399796429546708,"e2e_p50_ms":18177.407176961424,"e2e_p95_ms":40610.760836387635,"e2e_p99_ms":40787.45809826243,"itl_p50_ms":21.13135898252949,"itl_p95_ms":89.28018237929791,"itl_p99_ms":813.2635014201514,"validation_errors":[],"timestamp":"2026-07-18T11:02:36+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":32768,"osl":2048,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c8_i32768_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c8_i32768_o2048_a1.log"} +{"status":"COMPLETED","completed":5,"failed":0,"duration_s":40.45307073701406,"request_tps":0.12360001129469417,"input_tps":4050.1251701045385,"output_tps":253.13282313153366,"total_tps":4303.257993236072,"mean_input_tokens":32768.0,"mean_output_tokens":2048.0,"ttft_p50_ms":3631.382770021446,"ttft_p95_ms":3674.5375951984897,"ttft_p99_ms":3678.67734703701,"tpot_p50_ms":2.4015674259833006,"tpot_p95_ms":2.8941197830043515,"tpot_p99_ms":2.992470480493007,"e2e_p50_ms":8488.469503994565,"e2e_p95_ms":8566.258183214813,"e2e_p99_ms":8570.437751058489,"itl_p50_ms":14.242168981581926,"itl_p95_ms":16.595105340820734,"itl_p99_ms":18.014726681867618,"validation_errors":[],"timestamp":"2026-07-18T11:04:00+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":32768,"osl":2048,"concurrency":1,"num_prompts":5,"warmup_requests":1,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c1_i32768_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c1_i32768_o2048_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":237.88721667096252,"request_tps":0.33629381653850393,"input_tps":22039.351560667394,"output_tps":43.0456085169285,"total_tps":22082.39716918432,"mean_input_tokens":65536.0,"mean_output_tokens":128.0,"ttft_p50_ms":15999.346402473748,"ttft_p95_ms":33025.963873389985,"ttft_p99_ms":40039.445278539184,"tpot_p50_ms":238.88738007870444,"tpot_p95_ms":279.5536856362266,"tpot_p99_ms":296.4112355349599,"e2e_p50_ms":46561.53851299314,"e2e_p95_ms":65163.6855219811,"e2e_p99_ms":69527.01141068361,"itl_p50_ms":1316.0729939991143,"itl_p95_ms":1519.897556028445,"itl_p99_ms":1547.5808050466005,"validation_errors":[],"timestamp":"2026-07-18T11:08:51+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":65536,"osl":128,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c16_i65536_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c16_i65536_o128_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":176.17807112500304,"request_tps":0.22704301247354974,"input_tps":14879.490865466556,"output_tps":29.061505596614367,"total_tps":14908.55237106317,"mean_input_tokens":65536.0,"mean_output_tokens":128.0,"ttft_p50_ms":12941.712918516714,"ttft_p95_ms":28187.093603279183,"ttft_p99_ms":41648.59008794184,"tpot_p50_ms":180.5019874135344,"tpot_p95_ms":212.4629147444287,"tpot_p99_ms":226.08344668802513,"e2e_p50_ms":35543.81811252097,"e2e_p95_ms":51757.63051120445,"e2e_p99_ms":66881.69940962631,"itl_p50_ms":947.2226059879176,"itl_p95_ms":1326.1644615908153,"itl_p99_ms":1385.3814260009663,"validation_errors":[],"timestamp":"2026-07-18T11:12:39+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":65536,"osl":128,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c8_i65536_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c8_i65536_o128_a1.log"} +{"status":"COMPLETED","completed":5,"failed":0,"duration_s":25.300201695994474,"request_tps":0.19762688298218586,"input_tps":12951.675403120533,"output_tps":25.29624102171979,"total_tps":12976.971644142252,"mean_input_tokens":65536.0,"mean_output_tokens":128.0,"ttft_p50_ms":7645.312417007517,"ttft_p95_ms":7710.045675188303,"ttft_p99_ms":7716.139291021973,"tpot_p50_ms":1.9119230867180181,"tpot_p95_ms":2.4721476963471885,"tpot_p99_ms":2.5188319206670453,"e2e_p50_ms":7877.014378027525,"e2e_p95_ms":7947.007663990371,"e2e_p99_ms":7951.930831181817,"itl_p50_ms":13.26019101543352,"itl_p95_ms":17.468634276883677,"itl_p99_ms":18.35915795410981,"validation_errors":[],"timestamp":"2026-07-18T11:13:43+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":65536,"osl":128,"concurrency":1,"num_prompts":5,"warmup_requests":1,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c1_i65536_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c1_i65536_o128_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":246.04771068395348,"request_tps":0.32514019243511444,"input_tps":21308.38765142766,"output_tps":83.2358892633893,"total_tps":21391.62354069105,"mean_input_tokens":65536.0,"mean_output_tokens":256.0,"ttft_p50_ms":22371.516811515903,"ttft_p95_ms":39748.75297024846,"ttft_p99_ms":45080.21333112376,"tpot_p50_ms":97.20077570185394,"tpot_p95_ms":161.65417812956383,"tpot_p99_ms":206.10257677553486,"e2e_p50_ms":49042.79093752848,"e2e_p95_ms":64935.436250129715,"e2e_p99_ms":73895.55657390368,"itl_p50_ms":85.68069300963543,"itl_p95_ms":1498.3538402448175,"itl_p99_ms":1519.943565261201,"validation_errors":[],"timestamp":"2026-07-18T11:18:35+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":65536,"osl":256,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c16_i65536_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c16_i65536_o256_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":166.0298685450107,"request_tps":0.24092050635549353,"input_tps":15788.966304513624,"output_tps":61.675649627006344,"total_tps":15850.641954140629,"mean_input_tokens":65536.0,"mean_output_tokens":256.0,"ttft_p50_ms":18351.650577504188,"ttft_p95_ms":31612.372578898794,"ttft_p99_ms":35241.55389988213,"tpot_p50_ms":56.153139917695825,"tpot_p95_ms":89.21346703354794,"tpot_p99_ms":106.1797021546917,"e2e_p50_ms":32381.133827992016,"e2e_p95_ms":42088.93304417432,"e2e_p99_ms":52769.85401700541,"itl_p50_ms":21.83204749599099,"itl_p95_ms":1248.791667734622,"itl_p99_ms":1339.2206874937983,"validation_errors":[],"timestamp":"2026-07-18T11:22:13+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":65536,"osl":256,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c8_i65536_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c8_i65536_o256_a1.log"} +{"status":"COMPLETED","completed":5,"failed":0,"duration_s":34.09590293496149,"request_tps":0.1466451851865482,"input_tps":9610.538856385623,"output_tps":37.54116740775634,"total_tps":9648.08002379338,"mean_input_tokens":65536.0,"mean_output_tokens":256.0,"ttft_p50_ms":7665.277636027895,"ttft_p95_ms":7780.15266219154,"ttft_p99_ms":7796.318278834224,"tpot_p50_ms":2.0570641725926713,"tpot_p95_ms":2.6400503929357466,"tpot_p99_ms":2.7382582040485364,"e2e_p50_ms":8189.829000039026,"e2e_p95_ms":8300.137081195135,"e2e_p99_ms":8310.700003432576,"itl_p50_ms":13.311902992427349,"itl_p95_ms":16.836850799154483,"itl_p99_ms":18.20788355777041,"validation_errors":[],"timestamp":"2026-07-18T11:23:26+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":65536,"osl":256,"concurrency":1,"num_prompts":5,"warmup_requests":1,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c1_i65536_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c1_i65536_o256_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":287.4771158780204,"request_tps":0.27828302004374095,"input_tps":18237.556001586607,"output_tps":142.48090626239537,"total_tps":18380.036907849004,"mean_input_tokens":65536.0,"mean_output_tokens":512.0,"ttft_p50_ms":15595.835259999149,"ttft_p95_ms":35494.49952692084,"ttft_p99_ms":42268.533640111564,"tpot_p50_ms":80.66400910471155,"tpot_p95_ms":116.03631589093192,"tpot_p99_ms":125.36471763262483,"e2e_p50_ms":56755.209621507674,"e2e_p95_ms":84621.74609291833,"e2e_p99_ms":89025.08470444355,"itl_p50_ms":86.52475051349029,"itl_p95_ms":1429.1649397782749,"itl_p99_ms":1515.9596178418724,"validation_errors":[],"timestamp":"2026-07-18T11:28:57+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":65536,"osl":512,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c16_i65536_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c16_i65536_o512_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":176.08523362904089,"request_tps":0.22716271646189298,"input_tps":14887.335786046619,"output_tps":116.30731082848921,"total_tps":15003.643096875108,"mean_input_tokens":65536.0,"mean_output_tokens":512.0,"ttft_p50_ms":16064.022284030216,"ttft_p95_ms":31498.17883433134,"ttft_p99_ms":34776.059064161964,"tpot_p50_ms":33.15609084938219,"tpot_p95_ms":55.369937540185276,"tpot_p99_ms":62.18414084642529,"e2e_p50_ms":34336.03436301928,"e2e_p95_ms":49757.26835408422,"e2e_p99_ms":53672.993271836895,"itl_p50_ms":21.507173019926995,"itl_p95_ms":1090.6735533033498,"itl_p99_ms":1300.3444765962192,"validation_errors":[],"timestamp":"2026-07-18T11:32:46+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":65536,"osl":512,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c8_i65536_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c8_i65536_o512_a1.log"} +{"status":"COMPLETED","completed":5,"failed":0,"duration_s":37.98146427096799,"request_tps":0.13164316057772069,"input_tps":8627.366171621503,"output_tps":67.40129821579299,"total_tps":8694.767469837296,"mean_input_tokens":65536.0,"mean_output_tokens":512.0,"ttft_p50_ms":7672.744489042088,"ttft_p95_ms":7762.372077372856,"ttft_p99_ms":7779.512597839348,"tpot_p50_ms":2.3021282348645133,"tpot_p95_ms":3.38485259688031,"tpot_p99_ms":3.5508266321124613,"e2e_p50_ms":8839.277592021972,"e2e_p95_ms":8973.558043013327,"e2e_p99_ms":8980.524002225138,"itl_p50_ms":14.887171506416053,"itl_p95_ms":18.56181419279892,"itl_p99_ms":19.079410244012248,"validation_errors":[],"timestamp":"2026-07-18T11:34:07+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":65536,"osl":512,"concurrency":1,"num_prompts":5,"warmup_requests":1,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c1_i65536_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c1_i65536_o512_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":339.37426433200017,"request_tps":0.23572795113815195,"input_tps":15448.667005789926,"output_tps":241.3854219654676,"total_tps":15690.052427755394,"mean_input_tokens":65536.0,"mean_output_tokens":1024.0,"ttft_p50_ms":15513.732249499299,"ttft_p95_ms":45117.3673384299,"ttft_p99_ms":55654.33465670852,"tpot_p50_ms":48.44477799953096,"tpot_p95_ms":68.25563070067113,"tpot_p99_ms":75.32708569953621,"e2e_p50_ms":66847.44831101852,"e2e_p95_ms":92320.29078516352,"e2e_p99_ms":100010.70663718157,"itl_p50_ms":37.93419501744211,"itl_p95_ms":1257.1177008328957,"itl_p99_ms":1484.1483578574844,"validation_errors":[],"timestamp":"2026-07-18T11:40:31+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":65536,"osl":1024,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c16_i65536_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c16_i65536_o1024_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":208.56218499899842,"request_tps":0.1917893217324708,"input_tps":12569.104989059206,"output_tps":196.3922654540501,"total_tps":12765.497254513255,"mean_input_tokens":65536.0,"mean_output_tokens":1024.0,"ttft_p50_ms":12696.253194008023,"ttft_p95_ms":27730.65139459213,"ttft_p99_ms":34149.42511237284,"tpot_p50_ms":28.386475368018715,"tpot_p95_ms":41.99638848989234,"tpot_p99_ms":45.73432505272047,"e2e_p50_ms":41085.49446897814,"e2e_p95_ms":66584.3212218373,"e2e_p99_ms":70449.2399035266,"itl_p50_ms":21.475231973454356,"itl_p95_ms":1020.5841941817198,"itl_p99_ms":1179.4514456996699,"validation_errors":[],"timestamp":"2026-07-18T11:44:53+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":65536,"osl":1024,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c8_i65536_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c8_i65536_o1024_a1.log"} +{"status":"COMPLETED","completed":5,"failed":0,"duration_s":29.476278045971412,"request_tps":0.1696279290147136,"input_tps":11116.73595590827,"output_tps":173.69899931106673,"total_tps":11290.434955219338,"mean_input_tokens":65536.0,"mean_output_tokens":1024.0,"ttft_p50_ms":498.08889999985695,"ttft_p95_ms":7694.870659173466,"ttft_p99_ms":7708.817137409933,"tpot_p50_ms":2.403394970667338,"tpot_p95_ms":2.729593709105296,"tpot_p99_ms":2.7730399523934537,"e2e_p50_ms":3334.7405700478703,"e2e_p95_ms":10168.046947184484,"e2e_p99_ms":10189.837467826437,"itl_p50_ms":14.161175000481308,"itl_p95_ms":17.35297149280086,"itl_p99_ms":17.99791908590123,"validation_errors":[],"timestamp":"2026-07-18T11:46:01+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":65536,"osl":1024,"concurrency":1,"num_prompts":5,"warmup_requests":1,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c1_i65536_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c1_i65536_o1024_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":547.1302089389646,"request_tps":0.1462174793001138,"input_tps":19165.017446824517,"output_tps":18.715837350414567,"total_tps":19183.73328417493,"mean_input_tokens":131072.0,"mean_output_tokens":128.0,"ttft_p50_ms":71373.01887050853,"ttft_p95_ms":101880.66375631023,"ttft_p99_ms":162757.33266715583,"tpot_p50_ms":301.6628018306755,"tpot_p95_ms":354.4032030042919,"tpot_p99_ms":367.4735757588513,"e2e_p50_ms":108052.51780798426,"e2e_p95_ms":141458.0288458441,"e2e_p99_ms":205814.50931400282,"itl_p50_ms":1664.3900960334577,"itl_p95_ms":1750.0879329978488,"itl_p99_ms":1814.778513595229,"validation_errors":[],"timestamp":"2026-07-18T11:56:08+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":131072,"osl":128,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c16_i131072_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c16_i131072_o128_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":330.9426128079649,"request_tps":0.12086687676938927,"input_tps":15842.26327191739,"output_tps":15.470960226481827,"total_tps":15857.734232143872,"mean_input_tokens":131072.0,"mean_output_tokens":128.0,"ttft_p50_ms":30011.762386013288,"ttft_p95_ms":52413.35477800452,"ttft_p99_ms":74931.24330735183,"tpot_p50_ms":268.0270213699775,"tpot_p95_ms":311.62360475983417,"tpot_p99_ms":322.2466262936084,"e2e_p50_ms":65232.244025479304,"e2e_p95_ms":85262.86543083837,"e2e_p99_ms":112146.31149959634,"itl_p50_ms":1400.3960084810387,"itl_p95_ms":1730.057251852122,"itl_p99_ms":1748.0252843588823,"validation_errors":[],"timestamp":"2026-07-18T12:02:49+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":131072,"osl":128,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c8_i131072_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c8_i131072_o128_a1.log"} +{"status":"COMPLETED","completed":5,"failed":0,"duration_s":87.55952010804322,"request_tps":0.05710401329096252,"input_tps":7484.737230073039,"output_tps":7.309313701243203,"total_tps":7492.046543774283,"mean_input_tokens":131072.0,"mean_output_tokens":128.0,"ttft_p50_ms":17255.028521991335,"ttft_p95_ms":17437.021175189875,"ttft_p99_ms":17446.41588302795,"tpot_p50_ms":1.5932984327472102,"tpot_p95_ms":2.314733907096381,"tpot_p99_ms":2.455400091661947,"e2e_p50_ms":17459.67670099344,"e2e_p95_ms":17728.024377988186,"e2e_p99_ms":17757.65809398843,"itl_p50_ms":13.468926510540769,"itl_p95_ms":18.54823582689277,"itl_p99_ms":20.768109878990803,"validation_errors":[],"timestamp":"2026-07-18T12:05:17+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":131072,"osl":128,"concurrency":1,"num_prompts":5,"warmup_requests":1,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/raw_outputs/vllm_adaptive_c1_i131072_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp2_dp4/logs/vllm_c1_i131072_o128_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":27.55273042799672,"request_tps":2.9035234895889253,"input_tps":2973.2080533390595,"output_tps":371.65100666738243,"total_tps":3344.8590600064417,"mean_input_tokens":1024.0,"mean_output_tokens":128.0,"ttft_p50_ms":702.1135959948879,"ttft_p95_ms":15703.42596079281,"ttft_p99_ms":15722.90915462072,"tpot_p50_ms":13.978668039171465,"tpot_p95_ms":50.644176794760305,"tpot_p99_ms":141.22555111570168,"e2e_p50_ms":2780.017969518667,"e2e_p95_ms":17406.25057759753,"e2e_p99_ms":19103.088760495873,"itl_p50_ms":23.504939017584547,"itl_p95_ms":246.69269150181208,"itl_p99_ms":315.9365344850812,"validation_errors":[],"timestamp":"2026-07-18T12:18:52+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":128,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c16_i1024_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c16_i1024_o128_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":25.76212543202564,"request_tps":1.5526669220496399,"input_tps":1589.9309281788312,"output_tps":198.7413660223539,"total_tps":1788.672294201185,"mean_input_tokens":1024.0,"mean_output_tokens":128.0,"ttft_p50_ms":333.83394649717957,"ttft_p95_ms":11128.331195484498,"ttft_p99_ms":11130.58462173969,"tpot_p50_ms":12.310592594692176,"tpot_p95_ms":92.65198074650169,"tpot_p99_ms":97.85932620812673,"e2e_p50_ms":1932.1217600081582,"e2e_p95_ms":12810.768962529255,"e2e_p99_ms":12816.160397661151,"itl_p50_ms":18.768015987006947,"itl_p95_ms":220.59972196002488,"itl_p99_ms":289.66195689339656,"validation_errors":[],"timestamp":"2026-07-18T12:19:55+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":128,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c8_i1024_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c8_i1024_o128_a1.log"} +{"status":"COMPLETED","completed":5,"failed":0,"duration_s":1.8549794419668615,"request_tps":2.6954476620497894,"input_tps":2760.1384059389843,"output_tps":345.01730074237304,"total_tps":3105.1557066813575,"mean_input_tokens":1024.0,"mean_output_tokens":128.0,"ttft_p50_ms":119.24020695732906,"ttft_p95_ms":128.40212539304048,"ttft_p99_ms":129.45775307249278,"tpot_p50_ms":1.917534015566756,"tpot_p95_ms":2.29862234197689,"tpot_p99_ms":2.373920462339911,"e2e_p50_ms":367.23471799632534,"e2e_p95_ms":391.13325042417273,"e2e_p99_ms":394.7102045151405,"itl_p50_ms":10.906694980803877,"itl_p95_ms":12.32596730114892,"itl_p99_ms":13.827173275640234,"validation_errors":[],"timestamp":"2026-07-18T12:20:35+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":128,"concurrency":1,"num_prompts":5,"warmup_requests":1,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c1_i1024_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c1_i1024_o128_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":17.884944315010216,"request_tps":4.473036012354747,"input_tps":4580.388876651261,"output_tps":1145.0972191628152,"total_tps":5725.486095814076,"mean_input_tokens":1024.0,"mean_output_tokens":256.0,"ttft_p50_ms":379.6543045027647,"ttft_p95_ms":716.2737420090707,"ttft_p99_ms":723.0656019510934,"tpot_p50_ms":12.617589415658228,"tpot_p95_ms":17.130379428021044,"tpot_p99_ms":28.834599934890342,"e2e_p50_ms":3615.596199524589,"e2e_p95_ms":4643.986837661941,"e2e_p99_ms":7536.534365219397,"itl_p50_ms":31.223335477989167,"itl_p95_ms":231.19255113415417,"itl_p99_ms":254.95324280695058,"validation_errors":[],"timestamp":"2026-07-18T12:21:33+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":256,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c16_i1024_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c16_i1024_o256_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":31.276200532040093,"request_tps":5.115710900884273,"input_tps":5238.4879625054955,"output_tps":1309.6219906263739,"total_tps":6548.10995313187,"mean_input_tokens":1024.0,"mean_output_tokens":256.0,"ttft_p50_ms":750.5930115003139,"ttft_p95_ms":4476.9666695268825,"ttft_p99_ms":4599.8502393381195,"tpot_p50_ms":19.864935876445518,"tpot_p95_ms":30.37051490162196,"tpot_p99_ms":37.42907906419542,"e2e_p50_ms":6197.888160502771,"e2e_p95_ms":9355.69823462865,"e2e_p99_ms":11069.54205221729,"itl_p50_ms":33.63288502441719,"itl_p95_ms":279.28810459561623,"itl_p99_ms":299.10230743233114,"validation_errors":[],"timestamp":"2026-07-18T12:22:56+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":256,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":14.367756,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c32_i1024_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c32_i1024_o256_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":32.7462630259688,"request_tps":2.443026855814281,"input_tps":2501.6595003538237,"output_tps":1250.8297501769118,"total_tps":3752.4892505307353,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":308.7061364785768,"ttft_p95_ms":8862.519903035718,"ttft_p99_ms":8868.830288767349,"tpot_p50_ms":9.14592084053625,"tpot_p95_ms":20.93220928128227,"tpot_p99_ms":24.912487765572045,"e2e_p50_ms":5076.998848497169,"e2e_p95_ms":11724.725928946282,"e2e_p99_ms":12865.396913815632,"itl_p50_ms":22.55576098104939,"itl_p95_ms":89.97221577737946,"itl_p99_ms":216.9518971699288,"validation_errors":[],"timestamp":"2026-07-18T12:24:06+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":512,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c16_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c16_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":26.124274422996677,"request_tps":1.5311430033359625,"input_tps":1567.8904354160256,"output_tps":783.9452177080128,"total_tps":2351.8356531240383,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":280.99896397907287,"ttft_p95_ms":453.1571072642691,"ttft_p99_ms":456.3860837125685,"tpot_p50_ms":9.1442039657663,"tpot_p95_ms":16.38544433048075,"tpot_p99_ms":17.118565336888366,"e2e_p50_ms":4899.10372797749,"e2e_p95_ms":8614.395543595308,"e2e_p99_ms":8938.454784032656,"itl_p50_ms":18.110126024112105,"itl_p95_ms":94.58795201499015,"itl_p99_ms":254.52483681146987,"validation_errors":[],"timestamp":"2026-07-18T12:25:15+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":512,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c8_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c8_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":44.806077482004184,"request_tps":1.7854720720003001,"input_tps":1828.3234017283073,"output_tps":1828.3234017283073,"total_tps":3656.6468034566146,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":211.10930398572236,"ttft_p95_ms":340.6585612741764,"ttft_p99_ms":420.27828948106617,"tpot_p50_ms":7.36662962659192,"tpot_p95_ms":13.584714230408984,"tpot_p99_ms":17.86996977337983,"e2e_p50_ms":7750.942733488046,"e2e_p95_ms":14299.726498470405,"e2e_p99_ms":18465.088915716606,"itl_p50_ms":22.644823999144137,"itl_p95_ms":89.8953033844009,"itl_p99_ms":101.36252343887463,"validation_errors":[],"timestamp":"2026-07-18T12:26:36+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":1024,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c16_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c16_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":63.93186785199214,"request_tps":2.5026642482965458,"input_tps":2562.728190255663,"output_tps":2562.728190255663,"total_tps":5125.456380511326,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":334.2486814945005,"ttft_p95_ms":576.5540435240833,"ttft_p99_ms":833.108293010736,"tpot_p50_ms":11.966461585025518,"tpot_p95_ms":16.246475093749478,"tpot_p99_ms":18.947737075090618,"e2e_p50_ms":12447.81054800842,"e2e_p95_ms":17125.62227853341,"e2e_p99_ms":19811.44759819726,"itl_p50_ms":50.71867199148983,"itl_p95_ms":111.38751860707971,"itl_p99_ms":235.71937290485943,"validation_errors":[],"timestamp":"2026-07-18T12:28:21+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":1024,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":40.16821,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c32_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c32_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":78.23098600201774,"request_tps":3.0678381069338676,"input_tps":3141.4662215002804,"output_tps":3141.4662215002804,"total_tps":6282.932443000561,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":410.16011452302337,"ttft_p95_ms":5031.962670120993,"ttft_p99_ms":5039.296111369622,"tpot_p50_ms":12.852874526402157,"tpot_p95_ms":16.421496386867705,"tpot_p99_ms":22.62081301549535,"e2e_p50_ms":13771.750778018031,"e2e_p95_ms":18160.309876030075,"e2e_p99_ms":23416.788968951394,"itl_p50_ms":38.70429197559133,"itl_p95_ms":223.54913861490786,"itl_p99_ms":249.58885655854817,"validation_errors":[],"timestamp":"2026-07-18T12:30:27+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":1024,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":22.582888,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c48_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c48_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":66.86124038603157,"request_tps":1.1965078652162329,"input_tps":1225.2240539814225,"output_tps":2450.448107962845,"total_tps":3675.672161944267,"mean_input_tokens":1024.0,"mean_output_tokens":2048.0,"ttft_p50_ms":152.8250410046894,"ttft_p95_ms":333.6076223029522,"ttft_p99_ms":338.013706865604,"tpot_p50_ms":5.591458215908948,"tpot_p95_ms":9.091727054759456,"tpot_p99_ms":10.756706238099724,"e2e_p50_ms":11620.289143495029,"e2e_p95_ms":18713.35512548394,"e2e_p99_ms":22314.485002024434,"itl_p50_ms":22.512066992931068,"itl_p95_ms":86.9321528240107,"itl_p99_ms":90.10582223767413,"validation_errors":[],"timestamp":"2026-07-18T12:32:13+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":2048,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c16_i1024_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c16_i1024_o2048_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":126.4149456290179,"request_tps":1.2656731306877438,"input_tps":1296.0492858242496,"output_tps":2592.0985716484993,"total_tps":3888.1478574727494,"mean_input_tokens":1024.0,"mean_output_tokens":2048.0,"ttft_p50_ms":265.4589994926937,"ttft_p95_ms":726.6129045019625,"ttft_p99_ms":772.2280507569665,"tpot_p50_ms":11.100004712514613,"tpot_p95_ms":16.277339632317386,"tpot_p99_ms":19.24316772207052,"e2e_p50_ms":23000.561009015655,"e2e_p95_ms":33745.136883284424,"e2e_p99_ms":40082.02620854485,"itl_p50_ms":82.67961998353712,"itl_p95_ms":93.03711900429334,"itl_p99_ms":117.45555709640023,"validation_errors":[],"timestamp":"2026-07-18T12:34:58+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":2048,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":5.780594,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c32_i1024_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c32_i1024_o2048_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":110.93052892305423,"request_tps":2.163516232456382,"input_tps":2215.4406220353353,"output_tps":4430.881244070671,"total_tps":6646.3218661060055,"mean_input_tokens":1024.0,"mean_output_tokens":2048.0,"ttft_p50_ms":304.4261604663916,"ttft_p95_ms":872.5455140694976,"ttft_p99_ms":881.9954851671355,"tpot_p50_ms":8.890607387410853,"tpot_p95_ms":15.241644876378048,"tpot_p99_ms":17.995043008590642,"e2e_p50_ms":18450.517836987274,"e2e_p95_ms":31662.883282735125,"e2e_p99_ms":37083.66683233122,"itl_p50_ms":38.33038703305647,"itl_p95_ms":91.25756195280701,"itl_p99_ms":211.15881034405928,"validation_errors":[],"timestamp":"2026-07-18T12:37:34+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":2048,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":70.937992,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c48_i1024_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c48_i1024_o2048_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":150.75434364099056,"request_tps":2.122658573354639,"input_tps":2173.60237911515,"output_tps":4347.2047582303,"total_tps":6520.807137345451,"mean_input_tokens":1024.0,"mean_output_tokens":2048.0,"ttft_p50_ms":369.8994050209876,"ttft_p95_ms":1260.848580361926,"ttft_p99_ms":1275.8081526320893,"tpot_p50_ms":13.634657808993527,"tpot_p95_ms":17.568850779845803,"tpot_p99_ms":23.06478710351158,"e2e_p50_ms":28243.303587514674,"e2e_p95_ms":36482.3518924095,"e2e_p99_ms":47571.18241024611,"itl_p50_ms":82.37596147228032,"itl_p95_ms":158.0778770003235,"itl_p99_ms":242.5318615278229,"validation_errors":[],"timestamp":"2026-07-18T12:40:49+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":2048,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":-1.888484,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c64_i1024_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c64_i1024_o2048_a1.log"} +{"status":"COMPLETED","completed":400,"failed":0,"duration_s":159.78285385901108,"request_tps":2.503397519441925,"input_tps":2563.4790599085313,"output_tps":5126.958119817063,"total_tps":7690.437179725594,"mean_input_tokens":1024.0,"mean_output_tokens":2048.0,"ttft_p50_ms":429.98787548276596,"ttft_p95_ms":1313.0472420481965,"ttft_p99_ms":1411.3307138194796,"tpot_p50_ms":14.355235514407896,"tpot_p95_ms":18.64040917305456,"tpot_p99_ms":25.970387986664274,"e2e_p50_ms":30019.33769698371,"e2e_p95_ms":38757.601009949576,"e2e_p99_ms":53639.70004611299,"itl_p50_ms":82.29595102602616,"itl_p95_ms":192.15954699320716,"itl_p99_ms":245.20063582807754,"validation_errors":[],"timestamp":"2026-07-18T12:44:13+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":2048,"concurrency":80,"num_prompts":400,"warmup_requests":80,"attempt":1,"gain_pct":17.936891,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c80_i1024_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c80_i1024_o2048_a1.log"} +{"status":"COMPLETED","completed":480,"failed":0,"duration_s":181.61311484198086,"request_tps":2.6429809345962796,"input_tps":2706.4124770265903,"output_tps":5412.824954053181,"total_tps":8119.23743107977,"mean_input_tokens":1024.0,"mean_output_tokens":2048.0,"ttft_p50_ms":499.7578879992943,"ttft_p95_ms":2652.67279977852,"ttft_p99_ms":2959.572110766312,"tpot_p50_ms":16.590139245251912,"tpot_p95_ms":22.06068228016087,"tpot_p99_ms":28.16686336236382,"e2e_p50_ms":34425.116492493544,"e2e_p95_ms":45924.2779695487,"e2e_p99_ms":58697.7908300742,"itl_p50_ms":80.76879795407876,"itl_p95_ms":231.8597271107137,"itl_p99_ms":253.2423793850467,"validation_errors":[],"timestamp":"2026-07-18T12:48:01+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":2048,"concurrency":96,"num_prompts":480,"warmup_requests":96,"attempt":1,"gain_pct":5.575759,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c96_i1024_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c96_i1024_o2048_a1.log"} +{"status":"COMPLETED","completed":560,"failed":0,"duration_s":193.64390512299724,"request_tps":2.891906149301748,"input_tps":2961.31189688499,"output_tps":5922.62379376998,"total_tps":8883.935690654971,"mean_input_tokens":1024.0,"mean_output_tokens":2048.0,"ttft_p50_ms":548.9064514986239,"ttft_p95_ms":3362.3695748945465,"ttft_p99_ms":3940.084658745327,"tpot_p50_ms":17.40574554079731,"tpot_p95_ms":22.41554819524884,"tpot_p99_ms":29.104551309968752,"e2e_p50_ms":36193.08085448574,"e2e_p95_ms":46480.569969775366,"e2e_p99_ms":61005.07261475315,"itl_p50_ms":76.46691403351724,"itl_p95_ms":231.27494800428394,"itl_p99_ms":264.1079120134238,"validation_errors":[],"timestamp":"2026-07-18T12:51:57+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":2048,"concurrency":112,"num_prompts":560,"warmup_requests":112,"attempt":1,"gain_pct":9.418351,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c112_i1024_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c112_i1024_o2048_a1.log"} +{"status":"COMPLETED","completed":640,"failed":0,"duration_s":207.25412874895846,"request_tps":3.0879963832962543,"input_tps":3162.1082964953644,"output_tps":6324.216592990729,"total_tps":9486.324889486094,"mean_input_tokens":1024.0,"mean_output_tokens":2048.0,"ttft_p50_ms":573.7762104836293,"ttft_p95_ms":3960.3378175524995,"ttft_p99_ms":5166.016787358094,"tpot_p50_ms":18.49821653225551,"tpot_p95_ms":24.441312916250567,"tpot_p99_ms":32.44045878393925,"e2e_p50_ms":38522.50396145973,"e2e_p95_ms":51592.21037353562,"e2e_p99_ms":67346.64021471168,"itl_p50_ms":83.4613160113804,"itl_p95_ms":235.27385600027628,"itl_p99_ms":276.67007508571254,"validation_errors":[],"timestamp":"2026-07-18T12:56:10+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":2048,"concurrency":128,"num_prompts":640,"warmup_requests":128,"attempt":1,"gain_pct":6.780657,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c128_i1024_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c128_i1024_o2048_a1.log"} +{"status":"COMPLETED","completed":720,"failed":0,"duration_s":220.88241568399826,"request_tps":3.2596528690181295,"input_tps":3337.8845378745646,"output_tps":6675.769075749129,"total_tps":10013.653613623694,"mean_input_tokens":1024.0,"mean_output_tokens":2048.0,"ttft_p50_ms":591.7852114944253,"ttft_p95_ms":4029.0454154077456,"ttft_p99_ms":4806.015929778223,"tpot_p50_ms":19.64098608034718,"tpot_p95_ms":26.33298657736199,"tpot_p99_ms":30.74141857971994,"e2e_p50_ms":40939.097084483365,"e2e_p95_ms":54636.89930378167,"e2e_p99_ms":63306.26786959587,"itl_p50_ms":88.06721650762483,"itl_p95_ms":241.61228948214554,"itl_p99_ms":278.49465897772455,"validation_errors":[],"timestamp":"2026-07-18T13:00:40+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":2048,"concurrency":144,"num_prompts":720,"warmup_requests":144,"attempt":1,"gain_pct":5.558831,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c144_i1024_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c144_i1024_o2048_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":172.03298799699405,"request_tps":0.46502709120763425,"input_tps":476.18774139661747,"output_tps":1904.7509655864699,"total_tps":2380.9387069830873,"mean_input_tokens":1024.0,"mean_output_tokens":4096.0,"ttft_p50_ms":312.77381200925447,"ttft_p95_ms":1103.5133419500198,"ttft_p99_ms":1109.7220306645613,"tpot_p50_ms":8.433379815628136,"tpot_p95_ms":12.021598565986782,"tpot_p99_ms":13.578884898444965,"e2e_p50_ms":34962.857663980685,"e2e_p95_ms":49479.021549437304,"e2e_p99_ms":55799.0373232116,"itl_p50_ms":22.584245016332716,"itl_p95_ms":89.27137198334094,"itl_p99_ms":170.85746363329227,"validation_errors":[],"timestamp":"2026-07-18T13:04:12+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":4096,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c16_i1024_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c16_i1024_o4096_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":228.5375792060513,"request_tps":0.7001036790353972,"input_tps":716.9061673322467,"output_tps":2867.624669328987,"total_tps":3584.5308366612335,"mean_input_tokens":1024.0,"mean_output_tokens":4096.0,"ttft_p50_ms":334.1188019840047,"ttft_p95_ms":1424.1138277429854,"ttft_p99_ms":1682.8635884262621,"tpot_p50_ms":10.572199100494597,"tpot_p95_ms":15.664413859521183,"tpot_p99_ms":16.936726347751254,"e2e_p50_ms":43663.053852535086,"e2e_p95_ms":65395.606469214545,"e2e_p99_ms":69699.91860286333,"itl_p50_ms":36.66660998715088,"itl_p95_ms":91.23333698371425,"itl_p99_ms":205.88799711782485,"validation_errors":[],"timestamp":"2026-07-18T13:08:43+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":4096,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":50.55116,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c32_i1024_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c32_i1024_o4096_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":253.54176213900791,"request_tps":0.9465896189063187,"input_tps":969.3077697600703,"output_tps":3877.231079040281,"total_tps":4846.538848800352,"mean_input_tokens":1024.0,"mean_output_tokens":4096.0,"ttft_p50_ms":339.1998700099066,"ttft_p95_ms":1297.954389185179,"ttft_p99_ms":1307.0071972167352,"tpot_p50_ms":10.783791543830013,"tpot_p95_ms":16.121418162638356,"tpot_p99_ms":18.386727563150433,"e2e_p50_ms":44582.10645749932,"e2e_p95_ms":67205.32053354837,"e2e_p99_ms":75571.1739101901,"itl_p50_ms":42.828281002584845,"itl_p95_ms":94.29576563416047,"itl_p99_ms":215.395035209367,"validation_errors":[],"timestamp":"2026-07-18T13:13:43+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":4096,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":35.207063,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c48_i1024_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c48_i1024_o4096_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":267.46730120200664,"request_tps":1.1964079293502785,"input_tps":1225.1217196546852,"output_tps":4900.486878618741,"total_tps":6125.608598273426,"mean_input_tokens":1024.0,"mean_output_tokens":4096.0,"ttft_p50_ms":362.55626898491755,"ttft_p95_ms":2074.050536454888,"ttft_p99_ms":2096.353462372208,"tpot_p50_ms":12.960046203536923,"tpot_p95_ms":15.65150252081851,"tpot_p99_ms":18.559029987302356,"e2e_p50_ms":53422.92506000376,"e2e_p95_ms":64427.342494006734,"e2e_p99_ms":76471.10216671777,"itl_p50_ms":59.42031249287538,"itl_p95_ms":93.5363046999555,"itl_p99_ms":228.40286600694523,"validation_errors":[],"timestamp":"2026-07-18T13:19:02+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":4096,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":26.391406,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c64_i1024_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c64_i1024_o4096_a1.log"} +{"status":"COMPLETED","completed":400,"failed":0,"duration_s":277.9197172179702,"request_tps":1.4392645617377455,"input_tps":1473.8069112194514,"output_tps":5895.227644877806,"total_tps":7369.034556097256,"mean_input_tokens":1024.0,"mean_output_tokens":4096.0,"ttft_p50_ms":409.6495530102402,"ttft_p95_ms":2312.735875460203,"ttft_p99_ms":2958.8231937750243,"tpot_p50_ms":12.771281153363061,"tpot_p95_ms":16.04820114858144,"tpot_p99_ms":19.30957356039096,"e2e_p50_ms":52721.37721601757,"e2e_p95_ms":66298.7404650339,"e2e_p99_ms":79451.48710538108,"itl_p50_ms":55.8116789907217,"itl_p95_ms":99.61796616553333,"itl_p99_ms":239.1685213893652,"validation_errors":[],"timestamp":"2026-07-18T13:24:28+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":4096,"concurrency":80,"num_prompts":400,"warmup_requests":80,"attempt":1,"gain_pct":20.298815,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c80_i1024_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c80_i1024_o4096_a1.log"} +{"status":"COMPLETED","completed":480,"failed":0,"duration_s":314.2893605940044,"request_tps":1.5272550082280985,"input_tps":1563.9091284255728,"output_tps":6255.636513702291,"total_tps":7819.545642127864,"mean_input_tokens":1024.0,"mean_output_tokens":4096.0,"ttft_p50_ms":458.3064029866364,"ttft_p95_ms":3348.2863718585577,"ttft_p99_ms":3738.439042698592,"tpot_p50_ms":14.970964453480478,"tpot_p95_ms":18.424632761419765,"tpot_p99_ms":23.67564769948563,"e2e_p50_ms":61787.968126969645,"e2e_p95_ms":75902.34519702208,"e2e_p99_ms":97599.6883112914,"itl_p50_ms":76.82424003724009,"itl_p95_ms":189.30872951750644,"itl_p99_ms":250.1114904531278,"validation_errors":[],"timestamp":"2026-07-18T13:30:32+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":4096,"concurrency":96,"num_prompts":480,"warmup_requests":96,"attempt":1,"gain_pct":6.11357,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c96_i1024_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c96_i1024_o4096_a1.log"} +{"status":"COMPLETED","completed":560,"failed":0,"duration_s":358.13252101803664,"request_tps":1.563666986757108,"input_tps":1601.1949944392786,"output_tps":6404.7799777571145,"total_tps":8005.974972196393,"mean_input_tokens":1024.0,"mean_output_tokens":4096.0,"ttft_p50_ms":539.4234355189838,"ttft_p95_ms":4911.763646628242,"ttft_p99_ms":5673.59326924081,"tpot_p50_ms":15.972341098171638,"tpot_p95_ms":19.992609214978213,"tpot_p99_ms":24.311502859011302,"e2e_p50_ms":66246.64338448201,"e2e_p95_ms":83599.43223463486,"e2e_p99_ms":100535.43553544552,"itl_p50_ms":81.00825897417963,"itl_p95_ms":206.31670920411094,"itl_p99_ms":257.28272621519864,"validation_errors":[],"timestamp":"2026-07-18T13:37:21+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":4096,"concurrency":112,"num_prompts":560,"warmup_requests":112,"attempt":1,"gain_pct":2.384145,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c112_i1024_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c112_i1024_o4096_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":27.22011431597639,"request_tps":2.9390030868843686,"input_tps":12038.156643878374,"output_tps":376.1923951211992,"total_tps":12414.349038999573,"mean_input_tokens":4096.0,"mean_output_tokens":128.0,"ttft_p50_ms":2141.9295700325165,"ttft_p95_ms":3321.311524292104,"ttft_p99_ms":3814.6037162444554,"tpot_p50_ms":25.101325393784567,"tpot_p95_ms":40.93568425650312,"tpot_p99_ms":49.12117702925878,"e2e_p50_ms":5600.4653929849155,"e2e_p95_ms":7171.978995614335,"e2e_p99_ms":8690.520806995919,"itl_p50_ms":84.50854147667997,"itl_p95_ms":681.3402164843865,"itl_p99_ms":832.3174126562662,"validation_errors":[],"timestamp":"2026-07-18T13:38:28+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":128,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c16_i4096_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c16_i4096_o128_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":35.2387240829994,"request_tps":4.540459513322463,"input_tps":18597.72216656881,"output_tps":581.1788177052753,"total_tps":19178.900984274085,"mean_input_tokens":4096.0,"mean_output_tokens":128.0,"ttft_p50_ms":2438.760138960788,"ttft_p95_ms":4455.1431706961,"ttft_p99_ms":4907.464413138223,"tpot_p50_ms":34.41608419314606,"tpot_p95_ms":63.057528095714936,"tpot_p99_ms":70.32877090510335,"e2e_p50_ms":6932.157581002684,"e2e_p95_ms":11305.202879910938,"e2e_p99_ms":13305.170121756963,"itl_p50_ms":82.89849298307672,"itl_p95_ms":827.7908880263567,"itl_p99_ms":837.0485404040666,"validation_errors":[],"timestamp":"2026-07-18T13:39:39+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":128,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":54.489784,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c32_i4096_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c32_i4096_o128_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":18.046660521999,"request_tps":4.4329531163108795,"input_tps":18157.375964409362,"output_tps":1134.8359977755852,"total_tps":19292.21196218495,"mean_input_tokens":4096.0,"mean_output_tokens":256.0,"ttft_p50_ms":623.9037619961891,"ttft_p95_ms":1651.167468761559,"ttft_p99_ms":1926.1503598012494,"tpot_p50_ms":10.28961936073542,"tpot_p95_ms":17.883292800603048,"tpot_p99_ms":21.487197240898958,"e2e_p50_ms":3387.1520520187914,"e2e_p95_ms":5102.369618759258,"e2e_p99_ms":6423.408941021754,"itl_p50_ms":22.865292994538322,"itl_p95_ms":120.50379356660413,"itl_p99_ms":512.6973245013495,"validation_errors":[],"timestamp":"2026-07-18T13:40:38+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":256,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c16_i4096_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c16_i4096_o256_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":31.73254212900065,"request_tps":5.0421425220066,"input_tps":20652.615770139033,"output_tps":1290.7884856336896,"total_tps":21943.404255772723,"mean_input_tokens":4096.0,"mean_output_tokens":256.0,"ttft_p50_ms":1041.7435429990292,"ttft_p95_ms":2093.2784101576544,"ttft_p99_ms":2151.8876362027368,"tpot_p50_ms":20.153843429323068,"tpot_p95_ms":27.829135277093936,"tpot_p99_ms":36.87385049268749,"e2e_p50_ms":6180.691362998914,"e2e_p95_ms":8425.565304691552,"e2e_p99_ms":9978.208621246738,"itl_p50_ms":84.04843299649656,"itl_p95_ms":414.3076865002513,"itl_p99_ms":724.7662237321492,"validation_errors":[],"timestamp":"2026-07-18T13:41:50+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":256,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":13.742293,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c32_i4096_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c32_i4096_o256_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":43.4420311350259,"request_tps":5.52460356317216,"input_tps":22628.77619475317,"output_tps":1414.298512172073,"total_tps":24043.07470692524,"mean_input_tokens":4096.0,"mean_output_tokens":256.0,"ttft_p50_ms":1550.5522179882973,"ttft_p95_ms":3036.764637142187,"ttft_p99_ms":3579.6066386217713,"tpot_p50_ms":27.74971544322576,"tpot_p95_ms":50.5370661255666,"tpot_p99_ms":58.055656549039135,"e2e_p50_ms":8477.507000992773,"e2e_p95_ms":14526.382811521762,"e2e_p99_ms":17442.588114989332,"itl_p50_ms":43.19208400556818,"itl_p95_ms":753.334138583159,"itl_p99_ms":831.1743449175264,"validation_errors":[],"timestamp":"2026-07-18T13:43:17+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":256,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":9.568572,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c48_i4096_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c48_i4096_o256_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":56.529619134031236,"request_tps":5.66074926564219,"input_tps":23186.42899207041,"output_tps":1449.1518120044007,"total_tps":24635.58080407481,"mean_input_tokens":4096.0,"mean_output_tokens":256.0,"ttft_p50_ms":1593.2845119968988,"ttft_p95_ms":4161.399798380444,"ttft_p99_ms":5840.047736195265,"tpot_p50_ms":34.579446056844006,"tpot_p95_ms":65.96123935504106,"tpot_p99_ms":72.8525995891838,"e2e_p50_ms":9905.384788988158,"e2e_p95_ms":18574.271297387895,"e2e_p99_ms":21042.98962429806,"itl_p50_ms":85.53711499553174,"itl_p95_ms":758.7545270274859,"itl_p99_ms":838.6517646955326,"validation_errors":[],"timestamp":"2026-07-18T13:44:54+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":256,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":2.464352,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c64_i4096_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c64_i4096_o256_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":27.99847080896143,"request_tps":2.8572989055671756,"input_tps":11703.496317203151,"output_tps":1462.937039650394,"total_tps":13166.433356853544,"mean_input_tokens":4096.0,"mean_output_tokens":512.0,"ttft_p50_ms":324.86174852238037,"ttft_p95_ms":628.5225111118051,"ttft_p99_ms":850.9931930154562,"tpot_p50_ms":11.150614025470858,"tpot_p95_ms":15.28328419194275,"tpot_p99_ms":17.028486979915698,"e2e_p50_ms":6007.727160991635,"e2e_p95_ms":8126.049154772771,"e2e_p99_ms":9029.216072889969,"itl_p50_ms":23.644218017579988,"itl_p95_ms":94.78326898533851,"itl_p99_ms":243.13388797454544,"validation_errors":[],"timestamp":"2026-07-18T13:46:06+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":512,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c16_i4096_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c16_i4096_o512_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":30.621624452003743,"request_tps":5.225065712982785,"input_tps":21401.869160377486,"output_tps":2675.2336450471857,"total_tps":24077.10280542467,"mean_input_tokens":4096.0,"mean_output_tokens":512.0,"ttft_p50_ms":461.93946499261074,"ttft_p95_ms":1437.531725212466,"ttft_p99_ms":1454.1866872110404,"tpot_p50_ms":9.365527791578465,"tpot_p95_ms":17.585293350518235,"tpot_p99_ms":19.316195398938174,"e2e_p50_ms":5216.710029024398,"e2e_p95_ms":9272.368860448474,"e2e_p99_ms":10321.010921081177,"itl_p50_ms":32.61955000925809,"itl_p95_ms":123.86658706818702,"itl_p99_ms":384.74738091696054,"validation_errors":[],"timestamp":"2026-07-18T13:47:13+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":512,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":82.867312,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c32_i4096_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c32_i4096_o512_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":39.7667132979841,"request_tps":6.035198287613233,"input_tps":24720.172186063803,"output_tps":3090.0215232579753,"total_tps":27810.19370932178,"mean_input_tokens":4096.0,"mean_output_tokens":512.0,"ttft_p50_ms":605.5872599827126,"ttft_p95_ms":1391.4112662459956,"ttft_p99_ms":1419.226497077616,"tpot_p50_ms":13.554908288619982,"tpot_p95_ms":19.17252989114288,"tpot_p99_ms":21.328369449293724,"e2e_p50_ms":7492.859598016366,"e2e_p95_ms":10667.037293247995,"e2e_p99_ms":11611.545975122133,"itl_p50_ms":42.31992599670775,"itl_p95_ms":259.58504959126,"itl_p99_ms":452.36534708761616,"validation_errors":[],"timestamp":"2026-07-18T13:48:39+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":512,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":15.504735,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c48_i4096_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c48_i4096_o512_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":57.878438900981564,"request_tps":5.528829147369645,"input_tps":22646.084187626067,"output_tps":2830.7605234532584,"total_tps":25476.844711079324,"mean_input_tokens":4096.0,"mean_output_tokens":512.0,"ttft_p50_ms":769.6783074934501,"ttft_p95_ms":1563.0192228331,"ttft_p99_ms":2085.1223387487703,"tpot_p50_ms":19.358126269077058,"tpot_p95_ms":32.92944804757197,"tpot_p99_ms":36.236197994159646,"e2e_p50_ms":10724.766931001795,"e2e_p95_ms":17569.191282830434,"e2e_p99_ms":19436.18470150803,"itl_p50_ms":86.54402702813968,"itl_p95_ms":409.8153442610055,"itl_p99_ms":666.0086099873297,"validation_errors":[],"timestamp":"2026-07-18T13:50:16+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":512,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":-8.390265,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c64_i4096_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c64_i4096_o512_a1.log"} +{"status":"COMPLETED","completed":400,"failed":0,"duration_s":67.43901667598402,"request_tps":5.931284584439168,"input_tps":24294.541657862832,"output_tps":3036.817707232854,"total_tps":27331.359365095686,"mean_input_tokens":4096.0,"mean_output_tokens":512.0,"ttft_p50_ms":1135.8841944893356,"ttft_p95_ms":3891.294330256642,"ttft_p99_ms":5006.861383465584,"tpot_p50_ms":19.038161925651195,"tpot_p95_ms":43.74749262569678,"tpot_p99_ms":48.803857492887616,"e2e_p50_ms":11186.04323049658,"e2e_p95_ms":23529.81346817686,"e2e_p99_ms":25783.167465063158,"itl_p50_ms":53.394435468362644,"itl_p95_ms":543.8099937280639,"itl_p99_ms":834.7405128274113,"validation_errors":[],"timestamp":"2026-07-18T13:52:10+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":512,"concurrency":80,"num_prompts":400,"warmup_requests":80,"attempt":1,"gain_pct":7.279216,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c80_i4096_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c80_i4096_o512_a1.log"} +{"status":"COMPLETED","completed":480,"failed":0,"duration_s":85.51558466796996,"request_tps":5.613011965756751,"input_tps":22990.897011739653,"output_tps":2873.8621264674566,"total_tps":25864.75913820711,"mean_input_tokens":4096.0,"mean_output_tokens":512.0,"ttft_p50_ms":1334.730533475522,"ttft_p95_ms":2990.198944939766,"ttft_p99_ms":3513.6399793869236,"tpot_p50_ms":28.540309190858565,"tpot_p95_ms":49.84565305055065,"tpot_p99_ms":56.38413383462776,"e2e_p50_ms":15690.376740007196,"e2e_p95_ms":26639.907913579373,"e2e_p99_ms":30334.66870171478,"itl_p50_ms":83.79475399851799,"itl_p95_ms":670.422772213351,"itl_p99_ms":836.8258527922444,"validation_errors":[],"timestamp":"2026-07-18T13:54:15+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":512,"concurrency":96,"num_prompts":480,"warmup_requests":96,"attempt":1,"gain_pct":-5.365998,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c96_i4096_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c96_i4096_o512_a1.log"} +{"status":"COMPLETED","completed":560,"failed":0,"duration_s":101.54037772602169,"request_tps":5.5150474376902885,"input_tps":22589.63430477942,"output_tps":2823.7042880974277,"total_tps":25413.33859287685,"mean_input_tokens":4096.0,"mean_output_tokens":512.0,"ttft_p50_ms":1844.904370518634,"ttft_p95_ms":5014.616222862969,"ttft_p99_ms":5859.126667620731,"tpot_p50_ms":32.68436523975208,"tpot_p95_ms":56.726588806765754,"tpot_p99_ms":65.97424691818523,"e2e_p50_ms":19376.548313506646,"e2e_p95_ms":30294.926115221457,"e2e_p99_ms":35069.028933785725,"itl_p50_ms":77.86054100142792,"itl_p95_ms":803.0653005640488,"itl_p99_ms":842.4151976522988,"validation_errors":[],"timestamp":"2026-07-18T13:56:47+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":512,"concurrency":112,"num_prompts":560,"warmup_requests":112,"attempt":1,"gain_pct":-1.745311,"plateau_streak":2,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c112_i4096_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c112_i4096_o512_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":47.43124650104437,"request_tps":1.686651857193728,"input_tps":6908.5260070655095,"output_tps":1727.1315017663774,"total_tps":8635.657508831888,"mean_input_tokens":4096.0,"mean_output_tokens":1024.0,"ttft_p50_ms":497.9291454947088,"ttft_p95_ms":1417.1274083142634,"ttft_p99_ms":1432.0634464459722,"tpot_p50_ms":7.382002774675405,"tpot_p95_ms":15.614466263311423,"tpot_p99_ms":17.196760967163627,"e2e_p50_ms":8036.765209515579,"e2e_p95_ms":16289.743103410001,"e2e_p99_ms":17732.722182531106,"itl_p50_ms":22.946885495912284,"itl_p95_ms":90.64157650573179,"itl_p99_ms":385.1802756858523,"validation_errors":[],"timestamp":"2026-07-18T13:58:10+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":1024,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c16_i4096_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c16_i4096_o1024_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":71.52391574997455,"request_tps":2.2370139878710003,"input_tps":9162.809294319617,"output_tps":2290.7023235799043,"total_tps":11453.511617899521,"mean_input_tokens":4096.0,"mean_output_tokens":1024.0,"ttft_p50_ms":648.7530960002914,"ttft_p95_ms":3105.0401185289957,"ttft_p99_ms":3766.068743466749,"tpot_p50_ms":11.915902339660798,"tpot_p95_ms":18.198141525582024,"tpot_p99_ms":19.98673330879061,"e2e_p50_ms":12955.435316514922,"e2e_p95_ms":21203.90488477423,"e2e_p99_ms":22921.492646008846,"itl_p50_ms":32.63149701524526,"itl_p95_ms":366.09440825121897,"itl_p99_ms":411.1358694039518,"validation_errors":[],"timestamp":"2026-07-18T14:00:00+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":1024,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":32.630452,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c32_i4096_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c32_i4096_o1024_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":88.7452612890047,"request_tps":2.704369749032846,"input_tps":11077.098492038538,"output_tps":2769.2746230096345,"total_tps":13846.373115048173,"mean_input_tokens":4096.0,"mean_output_tokens":1024.0,"ttft_p50_ms":852.480426983675,"ttft_p95_ms":1899.4757680891748,"ttft_p99_ms":2382.527175215073,"tpot_p50_ms":16.7644621646974,"tpot_p95_ms":25.78671268742342,"tpot_p99_ms":29.068599364746213,"e2e_p50_ms":17831.161290989257,"e2e_p95_ms":27710.574431784335,"e2e_p99_ms":30609.131004905194,"itl_p50_ms":41.464387031737715,"itl_p95_ms":394.4005874102004,"itl_p99_ms":654.2170198005624,"validation_errors":[],"timestamp":"2026-07-18T14:02:12+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":1024,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":20.891946,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c48_i4096_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c48_i4096_o1024_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":101.18120225396706,"request_tps":3.162642792055316,"input_tps":12954.184876258574,"output_tps":3238.5462190646435,"total_tps":16192.731095323217,"mean_input_tokens":4096.0,"mean_output_tokens":1024.0,"ttft_p50_ms":913.7183874845505,"ttft_p95_ms":2834.6317440853454,"ttft_p99_ms":2852.4721657281043,"tpot_p50_ms":19.147673525870484,"tpot_p95_ms":26.915611402222204,"tpot_p99_ms":30.231372892311736,"e2e_p50_ms":20697.68482854124,"e2e_p95_ms":28399.3941697001,"e2e_p99_ms":31917.5283561874,"itl_p50_ms":46.56558204442263,"itl_p95_ms":408.9264934067613,"itl_p99_ms":667.5658659893088,"validation_errors":[],"timestamp":"2026-07-18T14:04:41+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":1024,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":16.94565,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c64_i4096_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c64_i4096_o1024_a1.log"} +{"status":"COMPLETED","completed":400,"failed":0,"duration_s":116.5798790139961,"request_tps":3.431123821564248,"input_tps":14053.88317312716,"output_tps":3513.47079328179,"total_tps":17567.35396640895,"mean_input_tokens":4096.0,"mean_output_tokens":1024.0,"ttft_p50_ms":1064.8526579898316,"ttft_p95_ms":6010.626716085244,"ttft_p99_ms":6026.051196480983,"tpot_p50_ms":19.906098629031163,"tpot_p95_ms":31.523654145184757,"tpot_p99_ms":35.16804689935655,"e2e_p50_ms":22330.99814550951,"e2e_p95_ms":33391.37123571709,"e2e_p99_ms":36342.606240835725,"itl_p50_ms":53.5458734666463,"itl_p95_ms":424.77359727490693,"itl_p99_ms":753.0130879924399,"validation_errors":[],"timestamp":"2026-07-18T14:07:21+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":1024,"concurrency":80,"num_prompts":400,"warmup_requests":80,"attempt":1,"gain_pct":8.489135,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c80_i4096_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c80_i4096_o1024_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":110.30247215996496,"request_tps":0.7252783952473963,"input_tps":2970.7403069333354,"output_tps":1485.3701534666677,"total_tps":4456.110460400003,"mean_input_tokens":4096.0,"mean_output_tokens":2048.0,"ttft_p50_ms":464.93340795859694,"ttft_p95_ms":1417.8406421036925,"ttft_p99_ms":1546.497201603488,"tpot_p50_ms":12.225483088675295,"tpot_p95_ms":14.35200886518349,"tpot_p99_ms":16.136399584736303,"e2e_p50_ms":25613.872642017668,"e2e_p95_ms":29599.96179542504,"e2e_p99_ms":33181.1984973843,"itl_p50_ms":34.90648549632169,"itl_p95_ms":89.74233011831528,"itl_p99_ms":374.2070718778996,"validation_errors":[],"timestamp":"2026-07-18T14:09:49+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":2048,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c16_i4096_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c16_i4096_o2048_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":103.73901397304144,"request_tps":1.5423319913333575,"input_tps":6317.391836501432,"output_tps":3158.695918250716,"total_tps":9476.087754752149,"mean_input_tokens":4096.0,"mean_output_tokens":2048.0,"ttft_p50_ms":511.4873945422005,"ttft_p95_ms":2173.93696812213,"ttft_p99_ms":3069.681907519697,"tpot_p50_ms":8.275641649488872,"tpot_p95_ms":15.702540762485905,"tpot_p99_ms":16.9180283517117,"e2e_p50_ms":18034.61154701654,"e2e_p95_ms":32966.3674156589,"e2e_p99_ms":35661.942175811855,"itl_p50_ms":30.878802004735917,"itl_p95_ms":89.34044040797744,"itl_p99_ms":387.8694101073779,"validation_errors":[],"timestamp":"2026-07-18T14:12:19+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":2048,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":112.653789,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c32_i4096_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c32_i4096_o2048_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":151.63072549400385,"request_tps":1.5827926643369563,"input_tps":6483.118753124173,"output_tps":3241.5593765620865,"total_tps":9724.67812968626,"mean_input_tokens":4096.0,"mean_output_tokens":2048.0,"ttft_p50_ms":815.1672395179048,"ttft_p95_ms":3673.891558102332,"ttft_p99_ms":4554.707461830112,"tpot_p50_ms":14.784824802390899,"tpot_p95_ms":18.80378662648374,"tpot_p99_ms":20.301492525808925,"e2e_p50_ms":31026.566861517495,"e2e_p95_ms":39356.09838272794,"e2e_p99_ms":42542.45675673938,"itl_p50_ms":41.31258500274271,"itl_p95_ms":386.319139203988,"itl_p99_ms":478.7212864332832,"validation_errors":[],"timestamp":"2026-07-18T14:15:37+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":2048,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":2.623344,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c48_i4096_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c48_i4096_o2048_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":154.33062494097976,"request_tps":2.0734705125594917,"input_tps":8492.935219443678,"output_tps":4246.467609721839,"total_tps":12739.402829165518,"mean_input_tokens":4096.0,"mean_output_tokens":2048.0,"ttft_p50_ms":732.5031249783933,"ttft_p95_ms":2654.7582150407834,"ttft_p99_ms":2701.5443983179284,"tpot_p50_ms":14.363878876653066,"tpot_p95_ms":19.825300548092166,"tpot_p99_ms":21.791717113537608,"e2e_p50_ms":29983.675021474482,"e2e_p95_ms":41473.51371461991,"e2e_p99_ms":45064.18578826473,"itl_p50_ms":46.03430099086836,"itl_p95_ms":393.1344833923504,"itl_p99_ms":441.86115277116187,"validation_errors":[],"timestamp":"2026-07-18T14:19:01+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":2048,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":31.000766,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c64_i4096_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c64_i4096_o2048_a1.log"} +{"status":"COMPLETED","completed":400,"failed":0,"duration_s":203.1832692109747,"request_tps":1.968666030196912,"input_tps":8063.656059686552,"output_tps":4031.828029843276,"total_tps":12095.484089529828,"mean_input_tokens":4096.0,"mean_output_tokens":2048.0,"ttft_p50_ms":957.4609975097701,"ttft_p95_ms":7312.105561152565,"ttft_p99_ms":9975.084261031585,"tpot_p50_ms":18.55110297557415,"tpot_p95_ms":24.4243444592176,"tpot_p99_ms":26.898495660942707,"e2e_p50_ms":39731.57678602729,"e2e_p95_ms":50667.26529032164,"e2e_p99_ms":55323.49770748462,"itl_p50_ms":62.349880987312645,"itl_p95_ms":403.4949099877849,"itl_p99_ms":666.6860323864965,"validation_errors":[],"timestamp":"2026-07-18T14:23:11+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":2048,"concurrency":80,"num_prompts":400,"warmup_requests":80,"attempt":1,"gain_pct":-5.054544,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c80_i4096_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c80_i4096_o2048_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":244.65817194397096,"request_tps":0.3269868296830108,"input_tps":1339.3380543816122,"output_tps":1339.3380543816122,"total_tps":2678.6761087632244,"mean_input_tokens":4096.0,"mean_output_tokens":4096.0,"ttft_p50_ms":484.2147324816324,"ttft_p95_ms":2313.05249822326,"ttft_p99_ms":2516.649604810518,"tpot_p50_ms":12.964153935651208,"tpot_p95_ms":15.554256122513822,"tpot_p99_ms":16.16439839215325,"e2e_p50_ms":53512.8542840248,"e2e_p95_ms":63846.90828000311,"e2e_p99_ms":66641.27709113235,"itl_p50_ms":83.67913798429072,"itl_p95_ms":90.12484301347286,"itl_p99_ms":375.6759045249782,"validation_errors":[],"timestamp":"2026-07-18T14:27:53+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":4096,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c16_i4096_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c16_i4096_o4096_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":286.1583902799757,"request_tps":0.5591309059414855,"input_tps":2290.2001907363247,"output_tps":2290.2001907363247,"total_tps":4580.400381472649,"mean_input_tokens":4096.0,"mean_output_tokens":4096.0,"ttft_p50_ms":572.1653614891693,"ttft_p95_ms":4079.780797645799,"ttft_p99_ms":4854.537294764887,"tpot_p50_ms":14.398871198417652,"tpot_p95_ms":17.16287440504587,"tpot_p99_ms":18.751736578179468,"e2e_p50_ms":59606.35682247812,"e2e_p95_ms":70814.54005908454,"e2e_p99_ms":76987.53419269281,"itl_p50_ms":83.69803099776618,"itl_p95_ms":91.29488900362048,"itl_p99_ms":388.9725479093613,"validation_errors":[],"timestamp":"2026-07-18T14:33:27+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":4096,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":70.994932,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c32_i4096_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c32_i4096_o4096_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":18.779589343990665,"request_tps":4.259944055997126,"input_tps":34897.461706728456,"output_tps":545.2728391676321,"total_tps":35442.73454589609,"mean_input_tokens":8192.0,"mean_output_tokens":128.0,"ttft_p50_ms":1411.5086019737646,"ttft_p95_ms":3088.871652330272,"ttft_p99_ms":3147.9542360000773,"tpot_p50_ms":18.33428636625937,"tpot_p95_ms":29.246941090292864,"tpot_p99_ms":34.86095646788608,"e2e_p50_ms":3704.051572509343,"e2e_p95_ms":5334.3507313140435,"e2e_p99_ms":5839.158882145998,"itl_p50_ms":26.20532552828081,"itl_p95_ms":650.8757110801525,"itl_p99_ms":851.3976623135386,"validation_errors":[],"timestamp":"2026-07-18T14:34:27+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":8192,"osl":128,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c16_i8192_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c16_i8192_o128_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":33.40236495900899,"request_tps":4.790079989735763,"input_tps":39240.33527591537,"output_tps":613.1302386861777,"total_tps":39853.46551460155,"mean_input_tokens":8192.0,"mean_output_tokens":128.0,"ttft_p50_ms":2449.104284023633,"ttft_p95_ms":4933.964842002024,"ttft_p99_ms":5504.487227597855,"tpot_p50_ms":32.61501421257267,"tpot_p95_ms":58.40097401874581,"tpot_p99_ms":66.39995515274111,"e2e_p50_ms":6903.132667997852,"e2e_p95_ms":9886.165952173178,"e2e_p99_ms":11457.87813970237,"itl_p50_ms":33.18703701370396,"itl_p95_ms":844.8355856875422,"itl_p99_ms":862.8832227736717,"validation_errors":[],"timestamp":"2026-07-18T14:35:41+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":8192,"osl":128,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":12.444669,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c32_i8192_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c32_i8192_o128_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":23.635156759992242,"request_tps":3.3847882124233584,"input_tps":27728.18503617215,"output_tps":866.5057823803797,"total_tps":28594.69081855253,"mean_input_tokens":8192.0,"mean_output_tokens":256.0,"ttft_p50_ms":1117.7524740051012,"ttft_p95_ms":2633.8125900394516,"ttft_p99_ms":2641.088329773047,"tpot_p50_ms":11.687386270575955,"tpot_p95_ms":24.394492117788495,"tpot_p99_ms":28.217354893684362,"e2e_p50_ms":4108.954099006951,"e2e_p95_ms":7360.131390197784,"e2e_p99_ms":8296.279628429906,"itl_p50_ms":23.69104599347338,"itl_p95_ms":214.4188883830791,"itl_p99_ms":676.140085302759,"validation_errors":[],"timestamp":"2026-07-18T14:36:47+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":8192,"osl":256,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c16_i8192_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c16_i8192_o256_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":31.752429460990243,"request_tps":5.038984503424205,"input_tps":41279.361052051085,"output_tps":1289.9800328765964,"total_tps":42569.34108492768,"mean_input_tokens":8192.0,"mean_output_tokens":256.0,"ttft_p50_ms":995.8374270354398,"ttft_p95_ms":1925.4935913515508,"ttft_p99_ms":2225.5410464317533,"tpot_p50_ms":19.370497005886634,"tpot_p95_ms":30.02332345779994,"tpot_p99_ms":36.344537604109405,"e2e_p50_ms":6054.405989998486,"e2e_p95_ms":8665.943969998621,"e2e_p99_ms":10451.009523569954,"itl_p50_ms":84.82863596873358,"itl_p95_ms":660.9048810205422,"itl_p99_ms":777.6268611778504,"validation_errors":[],"timestamp":"2026-07-18T14:37:55+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":8192,"osl":256,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":48.871486,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c32_i8192_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c32_i8192_o256_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":63.425211736001074,"request_tps":3.783984214336844,"input_tps":30998.398683847427,"output_tps":968.6999588702321,"total_tps":31967.098642717658,"mean_input_tokens":8192.0,"mean_output_tokens":256.0,"ttft_p50_ms":1864.418934477726,"ttft_p95_ms":6828.963505095438,"ttft_p99_ms":9847.940194982208,"tpot_p50_ms":29.577916811845796,"tpot_p95_ms":83.81164630330578,"tpot_p99_ms":93.55166699202255,"e2e_p50_ms":9268.244831531774,"e2e_p95_ms":27256.01194726478,"e2e_p99_ms":30649.080957072438,"itl_p50_ms":84.92485200986266,"itl_p95_ms":849.8363316932229,"itl_p99_ms":861.4118797180708,"validation_errors":[],"timestamp":"2026-07-18T14:39:41+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":8192,"osl":256,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":-24.905818,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c48_i8192_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c48_i8192_o256_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":31.223719076020643,"request_tps":2.5621547454108,"input_tps":20989.171674405272,"output_tps":1311.8232296503295,"total_tps":22300.994904055602,"mean_input_tokens":8192.0,"mean_output_tokens":512.0,"ttft_p50_ms":385.8378230361268,"ttft_p95_ms":922.1627007966163,"ttft_p99_ms":1049.2000581539469,"tpot_p50_ms":13.27334386009519,"tpot_p95_ms":17.293043933434497,"tpot_p99_ms":20.41424247245648,"e2e_p50_ms":7012.746904511005,"e2e_p95_ms":9039.9348973413,"e2e_p99_ms":11232.128519285432,"itl_p50_ms":73.87403800385073,"itl_p95_ms":96.01426983717828,"itl_p99_ms":230.09513533674175,"validation_errors":[],"timestamp":"2026-07-18T14:40:56+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":8192,"osl":512,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c16_i8192_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c16_i8192_o512_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":36.23409449897008,"request_tps":4.4157306043496645,"input_tps":36173.66511083245,"output_tps":2260.854069427028,"total_tps":38434.51918025948,"mean_input_tokens":8192.0,"mean_output_tokens":512.0,"ttft_p50_ms":602.4279510020278,"ttft_p95_ms":1125.6606781011214,"ttft_p99_ms":1132.205956474645,"tpot_p50_ms":11.788316885485091,"tpot_p95_ms":18.04823678443864,"tpot_p99_ms":20.177545991014057,"e2e_p50_ms":6528.189491509693,"e2e_p95_ms":9967.97636892006,"e2e_p99_ms":10591.113788437797,"itl_p50_ms":38.69511198718101,"itl_p95_ms":190.6878023990429,"itl_p99_ms":657.9062252212316,"validation_errors":[],"timestamp":"2026-07-18T14:42:14+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":8192,"osl":512,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":72.344415,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c32_i8192_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c32_i8192_o512_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":52.8022900489741,"request_tps":4.545257407915454,"input_tps":37234.7486856434,"output_tps":2327.1717928527123,"total_tps":39561.92047849611,"mean_input_tokens":8192.0,"mean_output_tokens":512.0,"ttft_p50_ms":1228.706787514966,"ttft_p95_ms":2773.5031005140627,"ttft_p99_ms":3449.0233732323386,"tpot_p50_ms":16.30000090702672,"tpot_p95_ms":32.104716169166714,"tpot_p99_ms":37.08756212667475,"e2e_p50_ms":9127.776621491648,"e2e_p95_ms":17695.74207043624,"e2e_p99_ms":22002.232841528596,"itl_p50_ms":39.17149250628427,"itl_p95_ms":670.3946934867417,"itl_p99_ms":743.5262282175246,"validation_errors":[],"timestamp":"2026-07-18T14:43:48+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":8192,"osl":512,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":2.933304,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c48_i8192_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c48_i8192_o512_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":96.33326613297686,"request_tps":3.321801625186021,"input_tps":27212.198913523884,"output_tps":1700.7624320952427,"total_tps":28912.961345619125,"mean_input_tokens":8192.0,"mean_output_tokens":512.0,"ttft_p50_ms":1547.2476850263774,"ttft_p95_ms":6823.872399938419,"ttft_p99_ms":8490.638438323513,"tpot_p50_ms":29.836521666326583,"tpot_p95_ms":64.46616107277521,"tpot_p99_ms":69.07564456338143,"e2e_p50_ms":16636.050895496737,"e2e_p95_ms":35513.621014513774,"e2e_p99_ms":36966.468555363244,"itl_p50_ms":82.19244299107231,"itl_p95_ms":834.8084404336986,"itl_p99_ms":855.2648624184076,"validation_errors":[],"timestamp":"2026-07-18T14:46:04+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":8192,"osl":512,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":-26.917195,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c64_i8192_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c64_i8192_o512_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":66.63694732100703,"request_tps":1.2005351868028973,"input_tps":9834.784250289335,"output_tps":1229.3480312861668,"total_tps":11064.132281575501,"mean_input_tokens":8192.0,"mean_output_tokens":1024.0,"ttft_p50_ms":395.204267493682,"ttft_p95_ms":1021.2197664717677,"ttft_p99_ms":1489.977255152189,"tpot_p50_ms":14.258615942317983,"tpot_p95_ms":17.806720423008265,"tpot_p99_ms":19.456923309974083,"e2e_p50_ms":15217.481846484588,"e2e_p95_ms":18609.62407909974,"e2e_p99_ms":20645.642022744287,"itl_p50_ms":83.11796648195013,"itl_p95_ms":90.4333302314626,"itl_p99_ms":274.043102521682,"validation_errors":[],"timestamp":"2026-07-18T14:47:48+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":8192,"osl":1024,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c16_i8192_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c16_i8192_o1024_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":75.69139325799188,"request_tps":2.113846675468699,"input_tps":17316.63196543958,"output_tps":2164.5789956799476,"total_tps":19481.210961119526,"mean_input_tokens":8192.0,"mean_output_tokens":1024.0,"ttft_p50_ms":1036.8189775035717,"ttft_p95_ms":4131.549823112437,"ttft_p99_ms":4669.448679322377,"tpot_p50_ms":13.220376605553758,"tpot_p95_ms":20.00872569086638,"tpot_p99_ms":21.681538134395556,"e2e_p50_ms":14802.987565519288,"e2e_p95_ms":22107.133047064417,"e2e_p99_ms":23042.810699187685,"itl_p50_ms":31.149736954830587,"itl_p95_ms":656.2205604161136,"itl_p99_ms":683.6715180240571,"validation_errors":[],"timestamp":"2026-07-18T14:49:49+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":8192,"osl":1024,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":76.075362,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c32_i8192_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c32_i8192_o1024_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":61.84530337702017,"request_tps":1.2935501263904472,"input_tps":10596.762635390543,"output_tps":2649.190658847636,"total_tps":13245.95329423818,"mean_input_tokens":8192.0,"mean_output_tokens":2048.0,"ttft_p50_ms":336.00716752698645,"ttft_p95_ms":2989.242724364157,"ttft_p99_ms":3213.8333873229567,"tpot_p50_ms":5.311383223001293,"tpot_p95_ms":7.086623514923719,"tpot_p99_ms":7.546982405796869,"e2e_p50_ms":11628.971066995291,"e2e_p95_ms":15444.825801718978,"e2e_p99_ms":15946.902572705872,"itl_p50_ms":22.624513978371397,"itl_p95_ms":68.55209609493599,"itl_p99_ms":125.71366837539233,"validation_errors":[],"timestamp":"2026-07-18T14:51:30+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":8192,"osl":2048,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c16_i8192_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c16_i8192_o2048_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":129.0264358560089,"request_tps":1.240055953948515,"input_tps":10158.538374746235,"output_tps":2539.6345936865587,"total_tps":12698.172968432793,"mean_input_tokens":8192.0,"mean_output_tokens":2048.0,"ttft_p50_ms":904.3930525076576,"ttft_p95_ms":2689.497368983575,"ttft_p99_ms":3086.1592555843526,"tpot_p50_ms":11.056232889834382,"tpot_p95_ms":17.67640581118512,"tpot_p99_ms":18.330815101541607,"e2e_p50_ms":23456.48364999215,"e2e_p95_ms":37538.587051062495,"e2e_p99_ms":38922.125476959045,"itl_p50_ms":31.39019350055605,"itl_p95_ms":108.9911603135988,"itl_p99_ms":665.4189008974936,"validation_errors":[],"timestamp":"2026-07-18T14:54:17+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":8192,"osl":2048,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":-4.135454,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c32_i8192_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c32_i8192_o2048_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":170.87220076099038,"request_tps":1.4045584883389135,"input_tps":11506.14313647238,"output_tps":2876.535784118095,"total_tps":14382.678920590475,"mean_input_tokens":8192.0,"mean_output_tokens":2048.0,"ttft_p50_ms":997.78005600092,"ttft_p95_ms":2330.8968230005116,"ttft_p99_ms":2825.5791104724617,"tpot_p50_ms":16.310977470445366,"tpot_p95_ms":23.582514693649628,"tpot_p99_ms":25.880396527082187,"e2e_p50_ms":34188.333877478726,"e2e_p95_ms":49198.08813282288,"e2e_p99_ms":54971.41830683977,"itl_p50_ms":41.684899013489485,"itl_p95_ms":255.3224979259539,"itl_p99_ms":682.0906277326867,"validation_errors":[],"timestamp":"2026-07-18T14:57:51+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":8192,"osl":2048,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":13.265735,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c48_i8192_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c48_i8192_o2048_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":231.02538703399478,"request_tps":1.3851291587833714,"input_tps":11346.978068753378,"output_tps":2836.7445171883446,"total_tps":14183.722585941723,"mean_input_tokens":8192.0,"mean_output_tokens":2048.0,"ttft_p50_ms":1625.0035309931263,"ttft_p95_ms":14168.803173128981,"ttft_p99_ms":17694.95357496082,"tpot_p50_ms":21.23310692233234,"tpot_p95_ms":28.32434936518996,"tpot_p99_ms":30.360697775872847,"e2e_p50_ms":45907.07584598567,"e2e_p95_ms":60211.24239984783,"e2e_p99_ms":64155.49299964216,"itl_p50_ms":47.363882506033406,"itl_p95_ms":667.1477180207146,"itl_p99_ms":824.1033992194571,"validation_errors":[],"timestamp":"2026-07-18T15:02:28+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":8192,"osl":2048,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":-1.383305,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c64_i8192_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c64_i8192_o2048_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":153.29414920095587,"request_tps":0.5218724942667359,"input_tps":4275.1794730331,"output_tps":2137.58973651655,"total_tps":6412.76920954965,"mean_input_tokens":8192.0,"mean_output_tokens":4096.0,"ttft_p50_ms":1192.0285335218068,"ttft_p95_ms":5935.390059446215,"ttft_p99_ms":7179.3965011200635,"tpot_p50_ms":6.610270673013947,"tpot_p95_ms":9.761382416859398,"tpot_p99_ms":11.469998583866662,"e2e_p50_ms":29238.940582465148,"e2e_p95_ms":42156.58511311049,"e2e_p99_ms":48130.838716678554,"itl_p50_ms":22.5645910250023,"itl_p95_ms":88.50669901585206,"itl_p99_ms":656.0197010287084,"validation_errors":[],"timestamp":"2026-07-18T15:05:42+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":8192,"osl":4096,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c16_i8192_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c16_i8192_o4096_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":229.8775818120339,"request_tps":0.1740056585104813,"input_tps":1425.4543545178628,"output_tps":712.7271772589314,"total_tps":2138.181531776794,"mean_input_tokens":8192.0,"mean_output_tokens":4096.0,"ttft_p50_ms":861.9409879902378,"ttft_p95_ms":1749.9126793496541,"ttft_p99_ms":1766.2296137138037,"tpot_p50_ms":13.575741198534768,"tpot_p95_ms":15.551349265678297,"tpot_p99_ms":16.435150156866516,"e2e_p50_ms":55992.64476398821,"e2e_p95_ms":64547.077329366584,"e2e_p99_ms":68090.60951995313,"itl_p50_ms":84.21155496034771,"itl_p95_ms":90.18874990870245,"itl_p99_ms":95.68792279809705,"validation_errors":[],"timestamp":"2026-07-18T15:10:11+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":8192,"osl":4096,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c8_i8192_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c8_i8192_o4096_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":45.51605002902215,"request_tps":1.7576217608731433,"input_tps":28796.87493014558,"output_tps":224.97558539176234,"total_tps":29021.850515537342,"mean_input_tokens":16384.0,"mean_output_tokens":128.0,"ttft_p50_ms":4025.9864950203337,"ttft_p95_ms":7652.217670419486,"ttft_p99_ms":7876.25755478977,"tpot_p50_ms":37.11173776766344,"tpot_p95_ms":63.707496391656974,"tpot_p99_ms":75.4920748534738,"e2e_p50_ms":9244.092236971483,"e2e_p95_ms":11385.31536940136,"e2e_p99_ms":13639.633960460156,"itl_p50_ms":25.560976995620877,"itl_p95_ms":868.0885115289128,"itl_p99_ms":894.0700479963562,"validation_errors":[],"timestamp":"2026-07-18T15:11:43+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":16384,"osl":128,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c16_i16384_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c16_i16384_o128_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":21.56110378401354,"request_tps":1.8551925912836598,"input_tps":30395.47541559148,"output_tps":237.46465168430845,"total_tps":30632.94006727579,"mean_input_tokens":16384.0,"mean_output_tokens":128.0,"ttft_p50_ms":2186.1488379945513,"ttft_p95_ms":4375.053679046686,"ttft_p99_ms":4528.036140928161,"tpot_p50_ms":16.977980267714827,"tpot_p95_ms":35.70141074557946,"tpot_p99_ms":39.01834399341312,"e2e_p50_ms":4448.456579964841,"e2e_p95_ms":5908.407387728219,"e2e_p99_ms":6806.7827262036735,"itl_p50_ms":18.763933971058577,"itl_p95_ms":655.9092082577988,"itl_p99_ms":844.3646207667186,"validation_errors":[],"timestamp":"2026-07-18T15:12:53+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":16384,"osl":128,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c8_i16384_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c8_i16384_o128_a1.log"} +{"status":"COMPLETED","completed":5,"failed":0,"duration_s":2.4712185590178706,"request_tps":2.023293318898971,"input_tps":33149.63773684074,"output_tps":258.9815448190683,"total_tps":33408.61928165981,"mean_input_tokens":16384.0,"mean_output_tokens":128.0,"ttft_p50_ms":231.10049299430102,"ttft_p95_ms":240.60293461661786,"ttft_p99_ms":240.80378774087876,"tpot_p50_ms":1.985667701022274,"tpot_p95_ms":2.291970250314087,"tpot_p99_ms":2.351780758664657,"e2e_p50_ms":483.5269199684262,"e2e_p95_ms":531.2593760085292,"e2e_p99_ms":539.3951880116947,"itl_p50_ms":11.429500009398907,"itl_p95_ms":14.235084780375473,"itl_p99_ms":14.78947491501458,"validation_errors":[],"timestamp":"2026-07-18T15:13:40+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":16384,"osl":128,"concurrency":1,"num_prompts":5,"warmup_requests":1,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c1_i16384_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c1_i16384_o128_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":29.186068111041095,"request_tps":2.7410338280453743,"input_tps":44909.09823869541,"output_tps":701.7046599796158,"total_tps":45610.80289867503,"mean_input_tokens":16384.0,"mean_output_tokens":256.0,"ttft_p50_ms":2349.43683250458,"ttft_p95_ms":5617.949891023453,"ttft_p99_ms":7209.092774376622,"tpot_p50_ms":12.747052127458886,"tpot_p95_ms":25.559840963117082,"tpot_p99_ms":27.97857476940702,"e2e_p50_ms":5230.467221495928,"e2e_p95_ms":8993.016205707681,"e2e_p99_ms":9998.620807266556,"itl_p50_ms":22.894673980772495,"itl_p95_ms":623.222791380249,"itl_p99_ms":841.7984525719658,"validation_errors":[],"timestamp":"2026-07-18T15:14:47+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":16384,"osl":256,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c16_i16384_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c16_i16384_o256_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":13.179264467034955,"request_tps":3.0350707431398196,"input_tps":49726.599055602805,"output_tps":776.9781102437938,"total_tps":50503.577165846604,"mean_input_tokens":16384.0,"mean_output_tokens":256.0,"ttft_p50_ms":519.1432425344829,"ttft_p95_ms":827.809068415081,"ttft_p99_ms":893.0817222088808,"tpot_p50_ms":6.660672572587489,"tpot_p95_ms":14.667134585119229,"tpot_p99_ms":17.214331572249932,"e2e_p50_ms":2334.692101489054,"e2e_p95_ms":4333.14335043542,"e2e_p99_ms":4947.897684568306,"itl_p50_ms":18.013563996646553,"itl_p95_ms":90.3527665825095,"itl_p99_ms":237.35449889558396,"validation_errors":[],"timestamp":"2026-07-18T15:15:44+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":16384,"osl":256,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c8_i16384_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c8_i16384_o256_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":43.603200489946175,"request_tps":1.8347277057895333,"input_tps":30060.178731655713,"output_tps":939.380585364241,"total_tps":30999.559317019954,"mean_input_tokens":16384.0,"mean_output_tokens":512.0,"ttft_p50_ms":672.6658010156825,"ttft_p95_ms":4119.379769105581,"ttft_p99_ms":4322.653419628622,"tpot_p50_ms":16.592671742665978,"tpot_p95_ms":25.537994861604606,"tpot_p99_ms":33.484805029415455,"e2e_p50_ms":8937.609429995064,"e2e_p95_ms":15155.921788394331,"e2e_p99_ms":18395.32086873599,"itl_p50_ms":68.69158998597413,"itl_p95_ms":160.63394349475857,"itl_p99_ms":692.2341679077363,"validation_errors":[],"timestamp":"2026-07-18T15:17:09+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":16384,"osl":512,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c16_i16384_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c16_i16384_o512_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":25.870633094978984,"request_tps":1.546154663210127,"input_tps":25332.198002034722,"output_tps":791.6311875635851,"total_tps":26123.82918959831,"mean_input_tokens":16384.0,"mean_output_tokens":512.0,"ttft_p50_ms":434.151968016522,"ttft_p95_ms":1093.60483731143,"ttft_p99_ms":1664.0504513285123,"tpot_p50_ms":6.563737439372123,"tpot_p95_ms":16.24128560653164,"tpot_p99_ms":16.533830804341846,"e2e_p50_ms":3943.7781249871477,"e2e_p95_ms":8597.014760179445,"e2e_p99_ms":8978.883442110964,"itl_p50_ms":18.077419023029506,"itl_p95_ms":90.7330057932995,"itl_p99_ms":243.880851384018,"validation_errors":[],"timestamp":"2026-07-18T15:18:23+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":16384,"osl":512,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c8_i16384_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c8_i16384_o512_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":42.838983570982236,"request_tps":1.867457939739482,"input_tps":30596.430884691672,"output_tps":1912.2769302932295,"total_tps":32508.7078149849,"mean_input_tokens":16384.0,"mean_output_tokens":1024.0,"ttft_p50_ms":420.2530069742352,"ttft_p95_ms":933.6000364855854,"ttft_p99_ms":2345.8827168057896,"tpot_p50_ms":6.340732230668985,"tpot_p95_ms":15.051045070176663,"tpot_p99_ms":15.5847806441362,"e2e_p50_ms":7302.928918477846,"e2e_p95_ms":16304.065234411972,"e2e_p99_ms":16718.630304282993,"itl_p50_ms":23.191691521788016,"itl_p95_ms":91.01111148484051,"itl_p99_ms":152.42629800632145,"validation_errors":[],"timestamp":"2026-07-18T15:19:48+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":16384,"osl":1024,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c16_i16384_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c16_i16384_o1024_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":135.35723718395457,"request_tps":1.1820572237489981,"input_tps":19366.825553903585,"output_tps":1210.426597118974,"total_tps":20577.25215102256,"mean_input_tokens":16384.0,"mean_output_tokens":1024.0,"ttft_p50_ms":1808.8729430455714,"ttft_p95_ms":5605.180043401197,"ttft_p99_ms":6484.979043864876,"tpot_p50_ms":25.05761878935366,"tpot_p95_ms":47.01662140160768,"tpot_p99_ms":53.318387600208055,"e2e_p50_ms":27313.77553648781,"e2e_p95_ms":50857.450406733544,"e2e_p99_ms":57009.378921393065,"itl_p50_ms":32.906904991250485,"itl_p95_ms":749.5023004012182,"itl_p99_ms":872.9596390691586,"validation_errors":[],"timestamp":"2026-07-18T15:22:44+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":16384,"osl":1024,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":-36.702338,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c32_i16384_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c32_i16384_o1024_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":136.47938897798304,"request_tps":0.5861690955614233,"input_tps":9603.794461678359,"output_tps":1200.4743077097949,"total_tps":10804.268769388154,"mean_input_tokens":16384.0,"mean_output_tokens":2048.0,"ttft_p50_ms":845.1261809677817,"ttft_p95_ms":3024.792128321132,"ttft_p99_ms":3674.3475427309686,"tpot_p50_ms":14.34593260454075,"tpot_p95_ms":18.034399795420974,"tpot_p99_ms":19.501994551997097,"e2e_p50_ms":29848.605251987465,"e2e_p95_ms":38446.411770931445,"e2e_p99_ms":41628.56246769079,"itl_p50_ms":83.67772999918088,"itl_p95_ms":91.26791423477698,"itl_p99_ms":667.7560643031031,"validation_errors":[],"timestamp":"2026-07-18T15:25:39+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":16384,"osl":2048,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c16_i16384_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c16_i16384_o2048_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":253.49201229203027,"request_tps":0.6311835964901146,"input_tps":10341.312044894037,"output_tps":1292.6640056117546,"total_tps":11633.976050505793,"mean_input_tokens":16384.0,"mean_output_tokens":2048.0,"ttft_p50_ms":3185.6273984885775,"ttft_p95_ms":8187.788197956955,"ttft_p99_ms":15317.867613557028,"tpot_p50_ms":21.392673939438836,"tpot_p95_ms":32.840285867346104,"tpot_p99_ms":35.86339617552936,"e2e_p50_ms":49073.69931600988,"e2e_p95_ms":69431.61327374399,"e2e_p99_ms":76572.03412171162,"itl_p50_ms":83.46344498568214,"itl_p95_ms":690.5175797612173,"itl_p99_ms":852.4438115180237,"validation_errors":[],"timestamp":"2026-07-18T15:30:35+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":16384,"osl":2048,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":7.679439,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c32_i16384_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c32_i16384_o2048_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":152.84197463997407,"request_tps":0.5234164252879059,"input_tps":17151.3094238341,"output_tps":66.99730243685195,"total_tps":17218.306726270952,"mean_input_tokens":32768.0,"mean_output_tokens":128.0,"ttft_p50_ms":9976.806119986577,"ttft_p95_ms":22058.714373197283,"ttft_p99_ms":29229.769541532703,"tpot_p50_ms":156.78777862601459,"tpot_p95_ms":184.81665041568544,"tpot_p99_ms":216.0315751642902,"e2e_p50_ms":30587.866124522407,"e2e_p95_ms":44675.245561249896,"e2e_p99_ms":50745.85203734923,"itl_p50_ms":904.8339805158321,"itl_p95_ms":954.8079339729156,"itl_p99_ms":960.4858378297649,"validation_errors":[],"timestamp":"2026-07-18T15:33:54+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":32768,"osl":128,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c16_i32768_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c16_i32768_o128_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":89.07475522701861,"request_tps":0.4490610150772213,"input_tps":14714.831342050387,"output_tps":57.479809929884325,"total_tps":14772.311151980271,"mean_input_tokens":32768.0,"mean_output_tokens":128.0,"ttft_p50_ms":8591.763256001286,"ttft_p95_ms":17678.12789125601,"ttft_p99_ms":19033.90099269454,"tpot_p50_ms":68.70173144096502,"tpot_p95_ms":112.97133418130521,"tpot_p99_ms":123.42131180892693,"e2e_p50_ms":18125.549655524082,"e2e_p95_ms":22666.15649272861,"e2e_p99_ms":28046.233472249005,"itl_p50_ms":86.78811497520655,"itl_p95_ms":918.2320259627886,"itl_p99_ms":940.6103475356938,"validation_errors":[],"timestamp":"2026-07-18T15:36:08+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":32768,"osl":128,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c8_i32768_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c8_i32768_o128_a1.log"} +{"status":"COMPLETED","completed":5,"failed":0,"duration_s":6.027769079024438,"request_tps":0.8294942846100573,"input_tps":27180.868718102356,"output_tps":106.17526843008733,"total_tps":27287.043986532444,"mean_input_tokens":32768.0,"mean_output_tokens":128.0,"ttft_p50_ms":365.47018797136843,"ttft_p95_ms":2669.9035497731525,"ttft_p99_ms":3130.459828337189,"tpot_p50_ms":2.14317377966528,"tpot_p95_ms":2.4237277716816235,"tpot_p99_ms":2.4685895984339727,"e2e_p50_ms":639.305226970464,"e2e_p95_ms":2907.191584387328,"e2e_p99_ms":3352.54881527042,"itl_p50_ms":13.100008014589548,"itl_p95_ms":15.802175315911878,"itl_p99_ms":16.678788289427754,"validation_errors":[],"timestamp":"2026-07-18T15:36:59+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":32768,"osl":128,"concurrency":1,"num_prompts":5,"warmup_requests":1,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c1_i32768_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c1_i32768_o128_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":142.76988772698678,"request_tps":0.5603422491511715,"input_tps":18361.294820185587,"output_tps":143.4476157826999,"total_tps":18504.742435968285,"mean_input_tokens":32768.0,"mean_output_tokens":256.0,"ttft_p50_ms":10795.846722496208,"ttft_p95_ms":19697.290377592435,"ttft_p99_ms":19971.76630709262,"tpot_p50_ms":70.071335770555,"tpot_p95_ms":104.29503950825664,"tpot_p99_ms":109.66800908955022,"e2e_p50_ms":28884.63925299584,"e2e_p95_ms":41694.75429139275,"e2e_p99_ms":44817.17456458077,"itl_p50_ms":88.28523851116188,"itl_p95_ms":929.7484528418863,"itl_p99_ms":949.8777458246329,"validation_errors":[],"timestamp":"2026-07-18T15:40:07+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":32768,"osl":256,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c16_i32768_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c16_i32768_o256_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":85.34323940199101,"request_tps":0.4686955906558525,"input_tps":15358.217114610974,"output_tps":119.98607120789823,"total_tps":15478.203185818873,"mean_input_tokens":32768.0,"mean_output_tokens":256.0,"ttft_p50_ms":9729.362564510666,"ttft_p95_ms":15828.297735648812,"ttft_p99_ms":16445.53222681279,"tpot_p50_ms":27.218507637278925,"tpot_p95_ms":51.46113339994176,"tpot_p99_ms":56.562267658812004,"e2e_p50_ms":17392.23462701193,"e2e_p95_ms":19613.343829417136,"e2e_p99_ms":20003.87705100176,"itl_p50_ms":17.9888479760848,"itl_p95_ms":912.4973707832396,"itl_p99_ms":934.0342972776853,"validation_errors":[],"timestamp":"2026-07-18T15:42:21+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":32768,"osl":256,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c8_i32768_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c8_i32768_o256_a1.log"} +{"status":"COMPLETED","completed":5,"failed":0,"duration_s":7.069011633051559,"request_tps":0.7073124588764602,"input_tps":23177.21465246385,"output_tps":181.07198947237382,"total_tps":23358.28664193622,"mean_input_tokens":32768.0,"mean_output_tokens":256.0,"ttft_p50_ms":340.23057704325765,"ttft_p95_ms":2673.3769097947506,"ttft_p99_ms":3139.6321627520956,"tpot_p50_ms":1.8472678902303326,"tpot_p95_ms":2.2686472211909643,"tpot_p99_ms":2.340028289705515,"e2e_p50_ms":829.5948240556754,"e2e_p95_ms":3144.7760970098893,"e2e_p99_ms":3588.8094650069247,"itl_p50_ms":11.27355097560212,"itl_p95_ms":13.095782021991909,"itl_p99_ms":13.865805394016206,"validation_errors":[],"timestamp":"2026-07-18T15:43:07+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":32768,"osl":256,"concurrency":1,"num_prompts":5,"warmup_requests":1,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c1_i32768_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c1_i32768_o256_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":143.377907698974,"request_tps":0.5579660164100195,"input_tps":18283.43042572352,"output_tps":285.67860040193,"total_tps":18569.10902612545,"mean_input_tokens":32768.0,"mean_output_tokens":512.0,"ttft_p50_ms":7831.71788949403,"ttft_p95_ms":17303.48952023487,"ttft_p99_ms":19079.997124051435,"tpot_p50_ms":40.0015425694279,"tpot_p95_ms":57.841255105882674,"tpot_p99_ms":69.54010008739407,"e2e_p50_ms":27929.903033509618,"e2e_p95_ms":40818.577464192625,"e2e_p99_ms":50723.781041466216,"itl_p50_ms":23.565200477605686,"itl_p95_ms":921.2140055373311,"itl_p99_ms":943.439543361892,"validation_errors":[],"timestamp":"2026-07-18T15:46:19+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":32768,"osl":512,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c16_i32768_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c16_i32768_o512_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":96.00002116902033,"request_tps":0.41666657478725844,"input_tps":13653.330322628884,"output_tps":213.33328629107632,"total_tps":13866.66360891996,"mean_input_tokens":32768.0,"mean_output_tokens":512.0,"ttft_p50_ms":7978.000472998247,"ttft_p95_ms":15638.641801924678,"ttft_p99_ms":16980.79572256771,"tpot_p50_ms":20.94151701861555,"tpot_p95_ms":37.87459104794392,"tpot_p99_ms":40.63855528741721,"e2e_p50_ms":18416.607558494434,"e2e_p95_ms":30299.68174783862,"e2e_p99_ms":32341.46790626575,"itl_p50_ms":18.12164601869881,"itl_p95_ms":880.0800114695448,"itl_p99_ms":926.6118227737024,"validation_errors":[],"timestamp":"2026-07-18T15:48:43+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":32768,"osl":512,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c8_i32768_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c8_i32768_o512_a1.log"} +{"status":"COMPLETED","completed":5,"failed":0,"duration_s":18.263042086036876,"request_tps":0.27377695218819986,"input_tps":8971.123169302933,"output_tps":140.17379952035833,"total_tps":9111.296968823292,"mean_input_tokens":32768.0,"mean_output_tokens":512.0,"ttft_p50_ms":3238.775165984407,"ttft_p95_ms":3284.711006388534,"ttft_p99_ms":3290.9883684595115,"tpot_p50_ms":1.8274198238849058,"tpot_p95_ms":2.2101233593040597,"tpot_p99_ms":2.2850924636439625,"e2e_p50_ms":4172.586695989594,"e2e_p95_ms":4212.772474589292,"e2e_p99_ms":4218.152802104596,"itl_p50_ms":11.253186967223883,"itl_p95_ms":11.68430905090645,"itl_p99_ms":13.721724390052264,"validation_errors":[],"timestamp":"2026-07-18T15:49:39+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":32768,"osl":512,"concurrency":1,"num_prompts":5,"warmup_requests":1,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c1_i32768_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c1_i32768_o512_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":183.2983048739843,"request_tps":0.43644702581946504,"input_tps":14301.49614205223,"output_tps":446.9217544391322,"total_tps":14748.417896491363,"mean_input_tokens":32768.0,"mean_output_tokens":1024.0,"ttft_p50_ms":7207.680581486784,"ttft_p95_ms":13678.858957166085,"ttft_p99_ms":17447.910063499578,"tpot_p50_ms":27.922000388572954,"tpot_p95_ms":40.865942139790974,"tpot_p99_ms":46.63040172787135,"e2e_p50_ms":35587.46461151168,"e2e_p95_ms":46429.864333148,"e2e_p99_ms":61033.15803387482,"itl_p50_ms":84.89173999987543,"itl_p95_ms":874.2435771331656,"itl_p99_ms":927.2950690612197,"validation_errors":[],"timestamp":"2026-07-18T15:53:31+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":32768,"osl":1024,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c16_i32768_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c16_i32768_o1024_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":123.64134554198245,"request_tps":0.32351637572900716,"input_tps":10600.984599888106,"output_tps":331.2807687465033,"total_tps":10932.265368634611,"mean_input_tokens":32768.0,"mean_output_tokens":1024.0,"ttft_p50_ms":5855.982561508426,"ttft_p95_ms":12642.991541716032,"ttft_p99_ms":14662.37526991521,"tpot_p50_ms":17.998665151013768,"tpot_p95_ms":30.59083824113096,"tpot_p99_ms":35.92404846914801,"e2e_p50_ms":24268.510930007324,"e2e_p95_ms":38381.03840936674,"e2e_p99_ms":42215.32203268376,"itl_p50_ms":18.033875996479765,"itl_p95_ms":719.1288994596107,"itl_p99_ms":906.1469934193884,"validation_errors":[],"timestamp":"2026-07-18T15:56:17+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":32768,"osl":1024,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c8_i32768_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c8_i32768_o1024_a1.log"} +{"status":"COMPLETED","completed":5,"failed":0,"duration_s":17.466588372015394,"request_tps":0.2862608251540923,"input_tps":9380.194718649296,"output_tps":293.1310849577905,"total_tps":9673.325803607086,"mean_input_tokens":32768.0,"mean_output_tokens":1024.0,"ttft_p50_ms":345.123587991111,"ttft_p95_ms":3248.947289993521,"ttft_p99_ms":3252.1658259886317,"tpot_p50_ms":1.865099392977442,"tpot_p95_ms":2.214924049850932,"tpot_p99_ms":2.284646927666298,"e2e_p50_ms":2688.6276670265943,"e2e_p95_ms":5143.519577221014,"e2e_p99_ms":5146.564952260815,"itl_p50_ms":11.258738493779674,"itl_p95_ms":11.60977101244498,"itl_p99_ms":13.715334105654616,"validation_errors":[],"timestamp":"2026-07-18T15:57:12+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":32768,"osl":1024,"concurrency":1,"num_prompts":5,"warmup_requests":1,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c1_i32768_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c1_i32768_o1024_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":184.65718245197786,"request_tps":0.4332352467297333,"input_tps":14196.2525648399,"output_tps":887.2657853024938,"total_tps":15083.518350142393,"mean_input_tokens":32768.0,"mean_output_tokens":2048.0,"ttft_p50_ms":5277.584327501245,"ttft_p95_ms":12298.414332958055,"ttft_p99_ms":14560.318431577174,"tpot_p50_ms":15.674740575465181,"tpot_p95_ms":22.23724090611313,"tpot_p99_ms":26.475459348199255,"e2e_p50_ms":40295.27226998471,"e2e_p95_ms":52810.52773059346,"e2e_p99_ms":61620.257761736255,"itl_p50_ms":23.155735980253667,"itl_p95_ms":714.3561964679974,"itl_p99_ms":913.7922631110986,"validation_errors":[],"timestamp":"2026-07-18T16:00:58+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":32768,"osl":2048,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c16_i32768_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c16_i32768_o2048_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":169.68467371497536,"request_tps":0.23573136644732717,"input_tps":7724.445415746017,"output_tps":482.77783848412605,"total_tps":8207.223254230143,"mean_input_tokens":32768.0,"mean_output_tokens":2048.0,"ttft_p50_ms":4921.975679957541,"ttft_p95_ms":13775.192025606517,"ttft_p99_ms":15645.7535359764,"tpot_p50_ms":13.230420246460525,"tpot_p95_ms":22.920834532945776,"tpot_p99_ms":24.223965232281966,"e2e_p50_ms":31618.161757476628,"e2e_p95_ms":56330.491617714855,"e2e_p99_ms":61129.55135967641,"itl_p50_ms":18.14902399200946,"itl_p95_ms":660.6972586014308,"itl_p99_ms":744.6949369693175,"validation_errors":[],"timestamp":"2026-07-18T16:04:36+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":32768,"osl":2048,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c8_i32768_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c8_i32768_o2048_a1.log"} +{"status":"COMPLETED","completed":5,"failed":0,"duration_s":27.76620302302763,"request_tps":0.18007503567748528,"input_tps":5900.698769079838,"output_tps":368.79367306748986,"total_tps":6269.492442147328,"mean_input_tokens":32768.0,"mean_output_tokens":2048.0,"ttft_p50_ms":353.8607439841144,"ttft_p95_ms":3277.1004185895436,"ttft_p99_ms":3283.267230100464,"tpot_p50_ms":1.9271949829174726,"tpot_p95_ms":2.1935151626777247,"tpot_p99_ms":2.243995037614347,"e2e_p50_ms":4973.1516619795,"e2e_p95_ms":7219.618505612016,"e2e_p99_ms":7250.542061924934,"itl_p50_ms":11.330151988659054,"itl_p95_ms":12.26643279660493,"itl_p99_ms":14.525764163117847,"validation_errors":[],"timestamp":"2026-07-18T16:05:46+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":32768,"osl":2048,"concurrency":1,"num_prompts":5,"warmup_requests":1,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c1_i32768_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c1_i32768_o2048_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":290.26618528401013,"request_tps":0.27560909281156615,"input_tps":18062.3175064988,"output_tps":35.27796387988047,"total_tps":18097.595470378677,"mean_input_tokens":65536.0,"mean_output_tokens":128.0,"ttft_p50_ms":34444.96556848753,"ttft_p95_ms":45299.528890047804,"ttft_p99_ms":45596.30676660337,"tpot_p50_ms":175.08930996070455,"tpot_p95_ms":210.94219701682715,"tpot_p99_ms":246.74174421435185,"e2e_p50_ms":54970.0428119977,"e2e_p95_ms":69854.77823939,"e2e_p99_ms":74921.13508200322,"itl_p50_ms":983.9354080031626,"itl_p95_ms":1075.5012832058128,"itl_p99_ms":1106.3202642952092,"validation_errors":[],"timestamp":"2026-07-18T16:11:26+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":65536,"osl":128,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c16_i65536_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c16_i65536_o128_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":172.44521094398806,"request_tps":0.23195773185601776,"input_tps":15201.58191491598,"output_tps":29.690589677570273,"total_tps":15231.27250459355,"mean_input_tokens":65536.0,"mean_output_tokens":128.0,"ttft_p50_ms":11974.84030452324,"ttft_p95_ms":25550.01282120647,"ttft_p99_ms":32275.876812592607,"tpot_p50_ms":169.33679697630876,"tpot_p95_ms":202.58272319331337,"tpot_p99_ms":212.71129841213644,"e2e_p50_ms":34448.21959998808,"e2e_p95_ms":47128.50430478282,"e2e_p99_ms":54640.55605423404,"itl_p50_ms":975.6934495235328,"itl_p95_ms":1044.3325913482113,"itl_p99_ms":1084.0679888072195,"validation_errors":[],"timestamp":"2026-07-18T16:15:12+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":65536,"osl":128,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c8_i65536_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c8_i65536_o128_a1.log"} +{"status":"COMPLETED","completed":5,"failed":0,"duration_s":35.55477995297406,"request_tps":0.14062806763572064,"input_tps":9216.201040574588,"output_tps":18.00039265737224,"total_tps":9234.20143323196,"mean_input_tokens":65536.0,"mean_output_tokens":128.0,"ttft_p50_ms":6881.991186994128,"ttft_p95_ms":6963.8256263919175,"ttft_p99_ms":6967.667116476223,"tpot_p50_ms":1.5336611967233165,"tpot_p95_ms":1.8620154944131164,"tpot_p99_ms":1.9189935239713902,"e2e_p50_ms":7076.766158977989,"e2e_p95_ms":7198.661502788309,"e2e_p99_ms":7211.051275741775,"itl_p50_ms":11.496535473270342,"itl_p95_ms":14.851098996587094,"itl_p99_ms":15.446150992647745,"validation_errors":[],"timestamp":"2026-07-18T16:16:34+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":65536,"osl":128,"concurrency":1,"num_prompts":5,"warmup_requests":1,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c1_i65536_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c1_i65536_o128_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":321.993663338013,"request_tps":0.2484520942762155,"input_tps":16282.55645048606,"output_tps":63.60373613471117,"total_tps":16346.160186620771,"mean_input_tokens":65536.0,"mean_output_tokens":256.0,"ttft_p50_ms":21289.90054546739,"ttft_p95_ms":44716.33441789015,"ttft_p99_ms":62388.30881347699,"tpot_p50_ms":166.94755952739084,"tpot_p95_ms":198.00746244919375,"tpot_p99_ms":207.21428923550803,"e2e_p50_ms":64268.27749446966,"e2e_p95_ms":94926.71471658394,"e2e_p99_ms":109047.5950071652,"itl_p50_ms":950.6594919948839,"itl_p95_ms":1047.5520689797122,"itl_p99_ms":1111.8354781961534,"validation_errors":[],"timestamp":"2026-07-18T16:22:40+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":65536,"osl":256,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c16_i65536_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c16_i65536_o256_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":175.0089891210082,"request_tps":0.22855968828173964,"input_tps":14978.88773123209,"output_tps":58.51128020012535,"total_tps":15037.399011432215,"mean_input_tokens":65536.0,"mean_output_tokens":256.0,"ttft_p50_ms":17521.20872150408,"ttft_p95_ms":30216.470251284765,"ttft_p99_ms":33677.372334969696,"tpot_p50_ms":65.29985771585237,"tpot_p95_ms":105.37510068466266,"tpot_p99_ms":122.3674557518999,"e2e_p50_ms":34891.767170018284,"e2e_p95_ms":43858.62500165239,"e2e_p99_ms":51192.81586824043,"itl_p50_ms":20.729840005515143,"itl_p95_ms":1034.5855785533786,"itl_p99_ms":1060.098131418345,"validation_errors":[],"timestamp":"2026-07-18T16:26:27+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":65536,"osl":256,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c8_i65536_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c8_i65536_o256_a1.log"} +{"status":"COMPLETED","completed":5,"failed":0,"duration_s":36.77602804300841,"request_tps":0.1359581299577175,"input_tps":8910.152004908974,"output_tps":34.80528126917568,"total_tps":8944.957286178149,"mean_input_tokens":65536.0,"mean_output_tokens":256.0,"ttft_p50_ms":6877.50015599886,"ttft_p95_ms":6968.481395021081,"ttft_p99_ms":6969.058144623414,"tpot_p50_ms":1.7123337803116325,"tpot_p95_ms":1.9778965074368116,"tpot_p99_ms":2.0281937328788144,"e2e_p50_ms":7314.145269978326,"e2e_p95_ms":7470.8393832203,"e2e_p99_ms":7485.846422268078,"itl_p50_ms":11.50744449114427,"itl_p95_ms":11.755705581163056,"itl_p99_ms":14.814665310550481,"validation_errors":[],"timestamp":"2026-07-18T16:27:51+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":65536,"osl":256,"concurrency":1,"num_prompts":5,"warmup_requests":1,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c1_i65536_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c1_i65536_o256_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":358.19147392897867,"request_tps":0.2233442329670365,"input_tps":14637.087651727705,"output_tps":114.3522472791227,"total_tps":14751.439899006828,"mean_input_tokens":65536.0,"mean_output_tokens":512.0,"ttft_p50_ms":18719.13023351226,"ttft_p95_ms":44608.437646226936,"ttft_p99_ms":60099.0140212193,"tpot_p50_ms":101.56615220938414,"tpot_p95_ms":133.79718352832174,"tpot_p99_ms":147.11114243396904,"e2e_p50_ms":69796.2264920061,"e2e_p95_ms":106316.79920407476,"e2e_p99_ms":129150.47490579828,"itl_p50_ms":748.6362740164623,"itl_p95_ms":1037.2414897778071,"itl_p99_ms":1052.406636972446,"validation_errors":[],"timestamp":"2026-07-18T16:34:32+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":65536,"osl":512,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c16_i65536_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c16_i65536_o512_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":196.6661982969963,"request_tps":0.20339031489078682,"input_tps":13329.387676682605,"output_tps":104.13584122408285,"total_tps":13433.523517906688,"mean_input_tokens":65536.0,"mean_output_tokens":512.0,"ttft_p50_ms":16612.24289800157,"ttft_p95_ms":32486.485953329244,"ttft_p99_ms":36334.10009618906,"tpot_p50_ms":43.721346965744466,"tpot_p95_ms":73.21938145414785,"tpot_p99_ms":75.21889673813644,"e2e_p50_ms":38592.282174533466,"e2e_p95_ms":62180.376574693946,"e2e_p99_ms":71765.7127494592,"itl_p50_ms":33.3622305188328,"itl_p95_ms":1008.0363147426397,"itl_p99_ms":1043.609487095382,"validation_errors":[],"timestamp":"2026-07-18T16:38:38+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":65536,"osl":512,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c8_i65536_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c8_i65536_o512_a1.log"} +{"status":"COMPLETED","completed":5,"failed":0,"duration_s":39.41220255900407,"request_tps":0.12686426221712657,"input_tps":8314.176288661607,"output_tps":64.9545022551688,"total_tps":8379.130790916777,"mean_input_tokens":65536.0,"mean_output_tokens":512.0,"ttft_p50_ms":6880.349103012122,"ttft_p95_ms":6969.971591804642,"ttft_p99_ms":6973.024264762644,"tpot_p50_ms":1.8236107357418614,"tpot_p95_ms":2.1728593729656924,"tpot_p99_ms":2.2382442894347974,"e2e_p50_ms":7816.859089012723,"e2e_p95_ms":8076.710943586658,"e2e_p99_ms":8116.048739103136,"itl_p50_ms":11.517838051076978,"itl_p95_ms":11.822154384572057,"itl_p99_ms":14.983186319004737,"validation_errors":[],"timestamp":"2026-07-18T16:40:02+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":65536,"osl":512,"concurrency":1,"num_prompts":5,"warmup_requests":1,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c1_i65536_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c1_i65536_o512_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":368.8525665909983,"request_tps":0.2168888256339772,"input_tps":14214.02607674833,"output_tps":222.09415744919266,"total_tps":14436.120234197522,"mean_input_tokens":65536.0,"mean_output_tokens":1024.0,"ttft_p50_ms":17797.122137999395,"ttft_p95_ms":41754.72097132587,"ttft_p99_ms":49824.98785163737,"tpot_p50_ms":54.684819562079795,"tpot_p95_ms":73.7884534625679,"tpot_p99_ms":76.15212988880288,"e2e_p50_ms":74560.24366198108,"e2e_p95_ms":103722.78252255345,"e2e_p99_ms":114636.74176812462,"itl_p50_ms":24.51944549102336,"itl_p95_ms":1016.8260887323413,"itl_p99_ms":1046.4533581823343,"validation_errors":[],"timestamp":"2026-07-18T16:46:52+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":65536,"osl":1024,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c16_i65536_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c16_i65536_o1024_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":242.00197419000324,"request_tps":0.16528790781101133,"input_tps":10832.308326302438,"output_tps":169.2548175984756,"total_tps":11001.563143900914,"mean_input_tokens":65536.0,"mean_output_tokens":1024.0,"ttft_p50_ms":11594.17327248957,"ttft_p95_ms":24408.198529810743,"ttft_p99_ms":34649.171954650665,"tpot_p50_ms":36.00014982408095,"tpot_p95_ms":51.19492883811023,"tpot_p99_ms":56.14070612732375,"e2e_p50_ms":49937.04811349744,"e2e_p95_ms":66765.10144116764,"e2e_p99_ms":69106.4128427516,"itl_p50_ms":84.65688800788485,"itl_p95_ms":927.6755607716041,"itl_p99_ms":1039.1474127973197,"validation_errors":[],"timestamp":"2026-07-18T16:51:42+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":65536,"osl":1024,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c8_i65536_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c8_i65536_o1024_a1.log"} +{"status":"COMPLETED","completed":5,"failed":0,"duration_s":44.459686835994944,"request_tps":0.11246143092379943,"input_tps":7370.272337022119,"output_tps":115.16050526597061,"total_tps":7485.43284228809,"mean_input_tokens":65536.0,"mean_output_tokens":1024.0,"ttft_p50_ms":6873.624835978262,"ttft_p95_ms":6975.482238014229,"ttft_p99_ms":6981.874952423386,"tpot_p50_ms":1.8625923782679912,"tpot_p95_ms":2.1825397542594973,"tpot_p99_ms":2.244411562196182,"e2e_p50_ms":8777.402237989008,"e2e_p95_ms":9205.995965620968,"e2e_p99_ms":9277.463092349935,"itl_p50_ms":11.506146984174848,"itl_p95_ms":11.689066584222019,"itl_p99_ms":12.066947724670163,"validation_errors":[],"timestamp":"2026-07-18T16:53:14+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":65536,"osl":1024,"concurrency":1,"num_prompts":5,"warmup_requests":1,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c1_i65536_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c1_i65536_o1024_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":737.7296400279738,"request_tps":0.10844081037189518,"input_tps":14213.553897065045,"output_tps":13.880423727602583,"total_tps":14227.434320792649,"mean_input_tokens":131072.0,"mean_output_tokens":128.0,"ttft_p50_ms":123244.77527750423,"ttft_p95_ms":126847.7361792553,"ttft_p99_ms":142683.43259234563,"tpot_p50_ms":196.81749726355986,"tpot_p95_ms":235.60987657399414,"tpot_p99_ms":251.03711323434018,"e2e_p50_ms":147684.30304250796,"e2e_p95_ms":156643.71573308308,"e2e_p99_ms":169583.1638545764,"itl_p50_ms":1043.5820659913588,"itl_p95_ms":1272.8044987656176,"itl_p99_ms":1368.8453135301822,"validation_errors":[],"timestamp":"2026-07-18T17:06:25+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":131072,"osl":128,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c16_i131072_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c16_i131072_o128_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":367.6234126780182,"request_tps":0.10880699819582457,"input_tps":14261.550867523118,"output_tps":13.927295769065545,"total_tps":14275.478163292184,"mean_input_tokens":131072.0,"mean_output_tokens":128.0,"ttft_p50_ms":48557.97014350537,"ttft_p95_ms":69407.30039756162,"ttft_p99_ms":85978.80098158143,"tpot_p50_ms":193.19172842931332,"tpot_p95_ms":233.24349165021434,"tpot_p99_ms":248.67801820558648,"e2e_p50_ms":73533.92783351592,"e2e_p95_ms":95308.31135720364,"e2e_p99_ms":109060.10606732742,"itl_p50_ms":1019.0691399911884,"itl_p95_ms":1274.79960739729,"itl_p99_ms":1380.1717375515727,"validation_errors":[],"timestamp":"2026-07-18T17:13:32+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":131072,"osl":128,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c8_i131072_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c8_i131072_o128_a1.log"} +{"status":"COMPLETED","completed":5,"failed":0,"duration_s":79.39933673897758,"request_tps":0.06297281822941818,"input_tps":8253.9732309663,"output_tps":8.060520733365527,"total_tps":8262.033751699666,"mean_input_tokens":131072.0,"mean_output_tokens":128.0,"ttft_p50_ms":15659.03412597254,"ttft_p95_ms":15845.724176382646,"ttft_p99_ms":15854.625453660265,"tpot_p50_ms":1.2799773303843214,"tpot_p95_ms":1.86359259376933,"tpot_p99_ms":1.9800417124858405,"e2e_p50_ms":15821.76519499626,"e2e_p95_ms":16081.535343185533,"e2e_p99_ms":16105.917732624803,"itl_p50_ms":11.749208031687886,"itl_p95_ms":17.31688203290105,"itl_p99_ms":19.56440940266476,"validation_errors":[],"timestamp":"2026-07-18T17:15:45+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":131072,"osl":128,"concurrency":1,"num_prompts":5,"warmup_requests":1,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/raw_outputs/vllm_adaptive_c1_i131072_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp4_dp2/logs/vllm_c1_i131072_o128_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":58.169735834002495,"request_tps":1.3752855991695403,"input_tps":1408.2924535496093,"output_tps":176.03655669370116,"total_tps":1584.3290102433104,"mean_input_tokens":1024.0,"mean_output_tokens":128.0,"ttft_p50_ms":4650.912018027157,"ttft_p95_ms":13825.13690808264,"ttft_p99_ms":14055.27102837863,"tpot_p50_ms":28.919784492202556,"tpot_p95_ms":117.86257663629874,"tpot_p99_ms":169.73726317765443,"e2e_p50_ms":13484.755601006327,"e2e_p95_ms":22016.345055267448,"e2e_p99_ms":27808.169543424152,"itl_p50_ms":23.106589971575886,"itl_p95_ms":541.824186709709,"itl_p99_ms":4758.209327593213,"validation_errors":[],"timestamp":"2026-07-18T17:29:27+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":128,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c16_i1024_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c16_i1024_o128_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":4.596489094023127,"request_tps":8.702294116614462,"input_tps":8911.14917541321,"output_tps":1113.8936469266512,"total_tps":10025.042822339861,"mean_input_tokens":1024.0,"mean_output_tokens":128.0,"ttft_p50_ms":255.94459602143615,"ttft_p95_ms":584.1602730448358,"ttft_p99_ms":584.4838791829534,"tpot_p50_ms":4.649203645586088,"tpot_p95_ms":7.603846217265468,"tpot_p99_ms":10.821609401325583,"e2e_p50_ms":844.2153414653149,"e2e_p95_ms":1334.6552902279655,"e2e_p99_ms":1561.2225204426793,"itl_p50_ms":16.734275966882706,"itl_p95_ms":53.910693200305104,"itl_p99_ms":186.7876676749438,"validation_errors":[],"timestamp":"2026-07-18T17:30:21+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":128,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c8_i1024_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c8_i1024_o128_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":9.798801889002789,"request_tps":8.164263438143813,"input_tps":8360.205760659264,"output_tps":2090.051440164816,"total_tps":10450.25720082408,"mean_input_tokens":1024.0,"mean_output_tokens":256.0,"ttft_p50_ms":279.87453000969253,"ttft_p95_ms":506.63872502918815,"ttft_p99_ms":542.5192111637443,"tpot_p50_ms":5.882874448948047,"tpot_p95_ms":9.205729769743686,"tpot_p99_ms":10.965191733998282,"e2e_p50_ms":1752.0265090279281,"e2e_p95_ms":2663.038983481237,"e2e_p99_ms":2961.5487904887386,"itl_p50_ms":22.85650500562042,"itl_p95_ms":61.59739967843052,"itl_p99_ms":189.67693113547284,"validation_errors":[],"timestamp":"2026-07-18T17:31:14+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":256,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c16_i1024_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c16_i1024_o256_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":18.66169183200691,"request_tps":8.573713543248095,"input_tps":8779.48266828605,"output_tps":2194.8706670715123,"total_tps":10974.353335357562,"mean_input_tokens":1024.0,"mean_output_tokens":256.0,"ttft_p50_ms":561.6029190132394,"ttft_p95_ms":840.7712341839214,"ttft_p99_ms":914.1952200472588,"tpot_p50_ms":12.512171194162768,"tpot_p95_ms":18.610768655255693,"tpot_p99_ms":25.38532880241708,"e2e_p50_ms":3541.201900487067,"e2e_p95_ms":5393.809601309476,"e2e_p99_ms":7296.4183634263445,"itl_p50_ms":32.082566496683285,"itl_p95_ms":198.64851864986122,"itl_p99_ms":325.4211212537484,"validation_errors":[],"timestamp":"2026-07-18T17:32:15+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":256,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":5.015151,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c32_i1024_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c32_i1024_o256_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":28.556197608006187,"request_tps":8.404480291616702,"input_tps":8606.187818615503,"output_tps":2151.5469546538757,"total_tps":10757.734773269378,"mean_input_tokens":1024.0,"mean_output_tokens":256.0,"ttft_p50_ms":589.6032589953393,"ttft_p95_ms":3504.7618285781937,"ttft_p99_ms":3567.9141352995057,"tpot_p50_ms":18.993084305810612,"tpot_p95_ms":27.984469945978503,"tpot_p99_ms":37.3602259846646,"e2e_p50_ms":5575.987120013451,"e2e_p95_ms":7981.638432247563,"e2e_p99_ms":10738.325889879476,"itl_p50_ms":42.30390494922176,"itl_p95_ms":227.54090519156304,"itl_p99_ms":333.37948774686083,"validation_errors":[],"timestamp":"2026-07-18T17:33:27+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":256,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":-1.973862,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c48_i1024_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c48_i1024_o256_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":27.23040886200033,"request_tps":11.751567948234362,"input_tps":12033.605578991986,"output_tps":3008.4013947479966,"total_tps":15042.006973739983,"mean_input_tokens":1024.0,"mean_output_tokens":256.0,"ttft_p50_ms":553.0225849943236,"ttft_p95_ms":1259.4555007905,"ttft_p99_ms":1430.6666003272403,"tpot_p50_ms":17.160656205812177,"tpot_p95_ms":28.15070322004841,"tpot_p99_ms":41.596425973568294,"e2e_p50_ms":4918.1921364797745,"e2e_p95_ms":7840.479278811836,"e2e_p99_ms":11034.098635988776,"itl_p50_ms":49.211177974939346,"itl_p95_ms":212.22659861668944,"itl_p99_ms":416.0771917132661,"validation_errors":[],"timestamp":"2026-07-18T17:34:33+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":256,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":39.82504,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c64_i1024_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c64_i1024_o256_a1.log"} +{"status":"COMPLETED","completed":400,"failed":0,"duration_s":34.22111374902306,"request_tps":11.688690290257403,"input_tps":11969.218857223581,"output_tps":2992.3047143058952,"total_tps":14961.523571529477,"mean_input_tokens":1024.0,"mean_output_tokens":256.0,"ttft_p50_ms":604.9174875079188,"ttft_p95_ms":1684.8847587330963,"ttft_p99_ms":3647.5512413919205,"tpot_p50_ms":19.85228269020844,"tpot_p95_ms":36.10795689053949,"tpot_p99_ms":54.20641034910702,"e2e_p50_ms":5986.324627476279,"e2e_p95_ms":9762.29243254928,"e2e_p99_ms":14308.843052086298,"itl_p50_ms":58.53447102708742,"itl_p95_ms":281.02737618610263,"itl_p99_ms":550.7901949505322,"validation_errors":[],"timestamp":"2026-07-18T17:35:51+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":256,"concurrency":80,"num_prompts":400,"warmup_requests":80,"attempt":1,"gain_pct":-0.535058,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c80_i1024_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c80_i1024_o256_a1.log"} +{"status":"COMPLETED","completed":480,"failed":0,"duration_s":44.37422855198383,"request_tps":10.817089460782089,"input_tps":11076.69960784086,"output_tps":2769.174901960215,"total_tps":13845.874509801075,"mean_input_tokens":1024.0,"mean_output_tokens":256.0,"ttft_p50_ms":648.0631924932823,"ttft_p95_ms":1805.7848204422041,"ttft_p99_ms":2135.9538255713414,"tpot_p50_ms":30.066121396079073,"tpot_p95_ms":42.43008320529114,"tpot_p99_ms":60.406570389490184,"e2e_p50_ms":8562.244452507002,"e2e_p95_ms":11376.78295592776,"e2e_p99_ms":16215.260048576734,"itl_p50_ms":157.97459898749366,"itl_p95_ms":293.38025202741846,"itl_p99_ms":425.10818511247635,"validation_errors":[],"timestamp":"2026-07-18T17:37:20+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":256,"concurrency":96,"num_prompts":480,"warmup_requests":96,"attempt":1,"gain_pct":-7.456788,"plateau_streak":2,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c96_i1024_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c96_i1024_o256_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":15.121119028015528,"request_tps":5.290613733797126,"input_tps":5417.588463408257,"output_tps":2708.7942317041284,"total_tps":8126.382695112386,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":166.80590700707398,"ttft_p95_ms":610.9136987506645,"ttft_p99_ms":614.1400695964694,"tpot_p50_ms":4.887602778906623,"tpot_p95_ms":6.810850084535121,"tpot_p99_ms":8.489205073625612,"e2e_p50_ms":2685.416329477448,"e2e_p95_ms":3750.4894609970506,"e2e_p99_ms":4615.626135251364,"itl_p50_ms":22.920668008737266,"itl_p95_ms":48.54268849012442,"itl_p99_ms":168.59680285095237,"validation_errors":[],"timestamp":"2026-07-18T17:38:14+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":512,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c16_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c16_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":22.638143029005732,"request_tps":7.067717515301307,"input_tps":7237.342735668539,"output_tps":3618.6713678342694,"total_tps":10856.014103502808,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":288.29390701139346,"ttft_p95_ms":715.8316138840746,"ttft_p99_ms":789.3937000317965,"tpot_p50_ms":7.345788989242517,"tpot_p95_ms":10.779483337798231,"tpot_p99_ms":13.49981067721766,"e2e_p50_ms":4164.6447604871355,"e2e_p95_ms":6157.1243254002175,"e2e_p99_ms":7440.133496702763,"itl_p50_ms":32.004165987018496,"itl_p95_ms":111.58274621702729,"itl_p99_ms":186.47971944883466,"validation_errors":[],"timestamp":"2026-07-18T17:39:14+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":512,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":33.589747,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c32_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c32_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":33.27099133096635,"request_tps":7.213491104385113,"input_tps":7386.614890890356,"output_tps":3693.307445445178,"total_tps":11079.922336335534,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":364.05927198939025,"ttft_p95_ms":1133.9173331711208,"ttft_p99_ms":1142.0316191535676,"tpot_p50_ms":11.054531667290854,"tpot_p95_ms":16.10260685518408,"tpot_p99_ms":21.92945509133386,"e2e_p50_ms":6042.133342009038,"e2e_p95_ms":8618.239563348467,"e2e_p99_ms":11465.512840322332,"itl_p50_ms":42.27217100560665,"itl_p95_ms":152.12864538189024,"itl_p99_ms":182.32234856113797,"validation_errors":[],"timestamp":"2026-07-18T17:40:24+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":512,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":2.062527,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c48_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c48_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":38.06645861599827,"request_tps":8.406350672860146,"input_tps":8608.10308900879,"output_tps":4304.051544504395,"total_tps":12912.154633513186,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":394.72965701133944,"ttft_p95_ms":1269.6075500512961,"ttft_p99_ms":1436.4797770383302,"tpot_p50_ms":12.970753024453424,"tpot_p95_ms":20.563863577544893,"tpot_p99_ms":24.46169894472505,"e2e_p50_ms":7028.701808478218,"e2e_p95_ms":11039.960625581447,"e2e_p99_ms":12723.231039931417,"itl_p50_ms":49.44362651440315,"itl_p95_ms":138.54116215370595,"itl_p99_ms":183.3385375404032,"validation_errors":[],"timestamp":"2026-07-18T17:41:42+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":512,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":16.536508,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c64_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c64_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":400,"failed":0,"duration_s":41.245501014986075,"request_tps":9.698027424970899,"input_tps":9930.7800831702,"output_tps":4965.3900415851,"total_tps":14896.170124755301,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":407.96267849509604,"ttft_p95_ms":1687.9733275767649,"ttft_p99_ms":1697.4284750205697,"tpot_p50_ms":13.962625378663988,"tpot_p95_ms":22.208899169823805,"tpot_p99_ms":28.48263250229768,"e2e_p50_ms":7567.46818398824,"e2e_p95_ms":11969.362801991518,"e2e_p99_ms":14920.626304004107,"itl_p50_ms":58.67316102376208,"itl_p95_ms":157.66264506382865,"itl_p99_ms":188.6623046640307,"validation_errors":[],"timestamp":"2026-07-18T17:43:05+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":512,"concurrency":80,"num_prompts":400,"warmup_requests":80,"attempt":1,"gain_pct":15.365487,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c80_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c80_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":480,"failed":0,"duration_s":68.19370798597811,"request_tps":7.038772552134823,"input_tps":7207.703093386059,"output_tps":3603.8515466930294,"total_tps":10811.554640079088,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":468.51731854258105,"ttft_p95_ms":1676.2428949354216,"ttft_p99_ms":2041.21697721479,"tpot_p50_ms":23.748336225046838,"tpot_p95_ms":33.80191224351421,"tpot_p99_ms":46.60455631605352,"e2e_p50_ms":12587.466079508886,"e2e_p95_ms":18151.28776158962,"e2e_p99_ms":24183.747104546055,"itl_p50_ms":120.19556801533327,"itl_p95_ms":224.23601871123537,"itl_p99_ms":297.0178122003563,"validation_errors":[],"timestamp":"2026-07-18T17:44:58+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":512,"concurrency":96,"num_prompts":480,"warmup_requests":96,"attempt":1,"gain_pct":-27.420575,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c96_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c96_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":560,"failed":0,"duration_s":79.68075408501318,"request_tps":7.0280459369463735,"input_tps":7196.719039433086,"output_tps":3598.359519716543,"total_tps":10795.07855914963,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":542.6139714836609,"ttft_p95_ms":2234.697953599971,"ttft_p99_ms":2250.7730272063054,"tpot_p50_ms":27.725097884543864,"tpot_p95_ms":40.73451551001149,"tpot_p99_ms":51.728642128695874,"e2e_p50_ms":14794.457307492848,"e2e_p95_ms":22010.66001293948,"e2e_p99_ms":27828.237652137177,"itl_p50_ms":143.36018095491454,"itl_p95_ms":236.00968196988103,"itl_p99_ms":365.80118853831664,"validation_errors":[],"timestamp":"2026-07-18T17:47:07+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":512,"concurrency":112,"num_prompts":560,"warmup_requests":112,"attempt":1,"gain_pct":-0.152393,"plateau_streak":2,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c112_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c112_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":25.708758165012114,"request_tps":3.1117800201207153,"input_tps":3186.4627406036125,"output_tps":3186.4627406036125,"total_tps":6372.925481207225,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":93.86357097537257,"ttft_p95_ms":505.8338033384644,"ttft_p99_ms":508.83548501646146,"tpot_p50_ms":4.3324252028602706,"tpot_p95_ms":6.275037016952523,"tpot_p99_ms":7.295468150576473,"e2e_p50_ms":4582.982399995672,"e2e_p95_ms":6700.186885378207,"e2e_p99_ms":7644.13922855455,"itl_p50_ms":22.967868018895388,"itl_p95_ms":46.71481451950967,"itl_p99_ms":49.95759673882276,"validation_errors":[],"timestamp":"2026-07-18T17:48:07+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":1024,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c16_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c16_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":36.80828772595851,"request_tps":4.346847133754672,"input_tps":4451.171464964784,"output_tps":4451.171464964784,"total_tps":8902.342929929568,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":180.900252511492,"ttft_p95_ms":662.8155737038469,"ttft_p99_ms":807.7487455419032,"tpot_p50_ms":6.235004860221819,"tpot_p95_ms":8.467538424562484,"tpot_p99_ms":11.196199942027187,"e2e_p50_ms":6674.5974690129515,"e2e_p95_ms":9066.687266828374,"e2e_p99_ms":12103.251558090558,"itl_p50_ms":32.25394798209891,"itl_p95_ms":56.411644487525336,"itl_p99_ms":155.92667976103257,"validation_errors":[],"timestamp":"2026-07-18T17:49:23+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":1024,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":39.690052,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c32_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c32_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":54.928696329006925,"request_tps":4.369300858015449,"input_tps":4474.16407860782,"output_tps":4474.16407860782,"total_tps":8948.32815721564,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":270.05254398682155,"ttft_p95_ms":988.16265539499,"ttft_p99_ms":1125.780833841418,"tpot_p50_ms":9.42052173411623,"tpot_p95_ms":12.733557371850862,"tpot_p99_ms":15.70427571543521,"e2e_p50_ms":9944.00310749188,"e2e_p95_ms":13688.103037994,"e2e_p99_ms":16616.689205036382,"itl_p50_ms":42.73128695785999,"itl_p95_ms":133.18895908887498,"itl_p99_ms":178.1008050125092,"validation_errors":[],"timestamp":"2026-07-18T17:50:55+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":1024,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":0.516552,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c48_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c48_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":68.02612712100381,"request_tps":4.704074942129059,"input_tps":4816.972740740156,"output_tps":4816.972740740156,"total_tps":9633.945481480312,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":348.19054752006195,"ttft_p95_ms":1234.2336929170415,"ttft_p99_ms":1427.7542339556385,"tpot_p50_ms":11.651139476046126,"tpot_p95_ms":17.895632307070766,"tpot_p99_ms":21.348126505629935,"e2e_p50_ms":12369.296489981934,"e2e_p95_ms":18628.938703268068,"e2e_p99_ms":22200.190662870886,"itl_p50_ms":50.04196398658678,"itl_p95_ms":143.9996785193216,"itl_p99_ms":210.5958190979436,"validation_errors":[],"timestamp":"2026-07-18T17:52:39+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":1024,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":7.66196,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c64_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c64_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":400,"failed":0,"duration_s":75.9900478409836,"request_tps":5.263847192688153,"input_tps":5390.179525312668,"output_tps":5390.179525312668,"total_tps":10780.359050625337,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":393.2137139781844,"ttft_p95_ms":1685.3338266024364,"ttft_p99_ms":1697.0744592067786,"tpot_p50_ms":12.960754025908221,"tpot_p95_ms":18.78369898668853,"tpot_p99_ms":25.431204606177612,"e2e_p50_ms":13831.582029990386,"e2e_p95_ms":19574.585413711604,"e2e_p99_ms":26285.612793198667,"itl_p50_ms":59.34287249692716,"itl_p95_ms":150.47198525280692,"itl_p99_ms":227.36941252078398,"validation_errors":[],"timestamp":"2026-07-18T17:54:37+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":1024,"concurrency":80,"num_prompts":400,"warmup_requests":80,"attempt":1,"gain_pct":11.899731,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c80_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c80_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":480,"failed":0,"duration_s":120.74462784500793,"request_tps":3.9753321416183,"input_tps":4070.7401130171393,"output_tps":4070.7401130171393,"total_tps":8141.4802260342785,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":406.7209505010396,"ttft_p95_ms":1621.6581199056234,"ttft_p99_ms":2015.240652196226,"tpot_p50_ms":21.831243248279264,"tpot_p95_ms":29.872420882035303,"tpot_p99_ms":40.3593105054978,"e2e_p50_ms":22726.930418983102,"e2e_p95_ms":31167.046548583312,"e2e_p99_ms":41682.65113493717,"itl_p50_ms":116.73112600692548,"itl_p95_ms":159.81756721157578,"itl_p99_ms":235.73814995877916,"validation_errors":[],"timestamp":"2026-07-18T17:57:18+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":1024,"concurrency":96,"num_prompts":480,"warmup_requests":96,"attempt":1,"gain_pct":-24.47858,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c96_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c96_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":560,"failed":0,"duration_s":134.6206986149773,"request_tps":4.159835788712041,"input_tps":4259.67184764113,"output_tps":4259.67184764113,"total_tps":8519.34369528226,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":472.3553440126125,"ttft_p95_ms":2230.4500721686054,"ttft_p99_ms":2247.91618657473,"tpot_p50_ms":23.98421157723637,"tpot_p95_ms":33.19837232821898,"tpot_p99_ms":44.48030495878503,"e2e_p50_ms":25223.519470513565,"e2e_p95_ms":34593.23796765819,"e2e_p99_ms":46248.903650895794,"itl_p50_ms":125.86904500494711,"itl_p95_ms":188.36334883817472,"itl_p99_ms":248.43743612233084,"validation_errors":[],"timestamp":"2026-07-18T18:00:15+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":1024,"concurrency":112,"num_prompts":560,"warmup_requests":112,"attempt":1,"gain_pct":4.641213,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c112_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c112_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":640,"failed":0,"duration_s":140.3585952440044,"request_tps":4.559749254311082,"input_tps":4669.1832364145475,"output_tps":4669.1832364145475,"total_tps":9338.366472829095,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":512.1842920198105,"ttft_p95_ms":2297.6709165988723,"ttft_p99_ms":2698.3152570336824,"tpot_p50_ms":25.209017690609798,"tpot_p95_ms":34.196737400399016,"tpot_p99_ms":44.79328554979572,"e2e_p50_ms":26350.056561961537,"e2e_p95_ms":36534.25090228265,"e2e_p99_ms":46575.111885954975,"itl_p50_ms":126.69642898254097,"itl_p95_ms":193.16382001852617,"itl_p99_ms":261.294651471544,"validation_errors":[],"timestamp":"2026-07-18T18:03:18+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":1024,"concurrency":128,"num_prompts":640,"warmup_requests":128,"attempt":1,"gain_pct":9.613684,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c128_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c128_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":720,"failed":0,"duration_s":156.09361435996834,"request_tps":4.612616620815788,"input_tps":4723.319419715367,"output_tps":4723.319419715367,"total_tps":9446.638839430734,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":2268.05771200452,"ttft_p95_ms":12847.59909079583,"ttft_p99_ms":27021.624898518785,"tpot_p50_ms":24.8640570039078,"tpot_p95_ms":33.92013949311631,"tpot_p99_ms":43.23333930469347,"e2e_p50_ms":28385.863465984585,"e2e_p95_ms":42436.39467631,"e2e_p99_ms":51427.05075933067,"itl_p50_ms":128.51797151961364,"itl_p95_ms":188.19730674731545,"itl_p99_ms":273.0190666235271,"validation_errors":[],"timestamp":"2026-07-18T18:06:38+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":1024,"concurrency":144,"num_prompts":720,"warmup_requests":144,"attempt":1,"gain_pct":1.159436,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c144_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c144_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":52.038706424005795,"request_tps":1.5373172297591062,"input_tps":1574.2128432733248,"output_tps":3148.4256865466496,"total_tps":4722.638529819975,"mean_input_tokens":1024.0,"mean_output_tokens":2048.0,"ttft_p50_ms":159.52791497693397,"ttft_p95_ms":474.81325024855323,"ttft_p99_ms":477.92372107389383,"tpot_p50_ms":4.494272679059562,"tpot_p95_ms":5.628632307743882,"tpot_p99_ms":6.7170544545268855,"e2e_p50_ms":9377.426032471703,"e2e_p95_ms":11713.905852165772,"e2e_p99_ms":13922.074954221014,"itl_p50_ms":23.118306999094784,"itl_p95_ms":24.50902520213276,"itl_p99_ms":114.46752397809178,"validation_errors":[],"timestamp":"2026-07-18T18:08:05+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":2048,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c16_i1024_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c16_i1024_o2048_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":71.9053317179787,"request_tps":2.225147929607489,"input_tps":2278.5514799180687,"output_tps":4557.102959836137,"total_tps":6835.654439754206,"mean_input_tokens":1024.0,"mean_output_tokens":2048.0,"ttft_p50_ms":251.7743335047271,"ttft_p95_ms":679.6242321870523,"ttft_p99_ms":807.8633775311755,"tpot_p50_ms":6.492404609926101,"tpot_p95_ms":8.093744889602645,"tpot_p99_ms":10.19435325121126,"e2e_p50_ms":13568.51726397872,"e2e_p95_ms":16902.78010051697,"e2e_p99_ms":21481.260838810118,"itl_p50_ms":32.49628597404808,"itl_p95_ms":56.12917550024576,"itl_p99_ms":120.72477500652894,"validation_errors":[],"timestamp":"2026-07-18T18:10:00+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":2048,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":44.742275,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c32_i1024_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c32_i1024_o2048_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":99.25165066996124,"request_tps":2.4180958037470366,"input_tps":2476.1301030369655,"output_tps":4952.260206073931,"total_tps":7428.390309110896,"mean_input_tokens":1024.0,"mean_output_tokens":2048.0,"ttft_p50_ms":272.85466849571094,"ttft_p95_ms":1130.9987220243784,"ttft_p99_ms":1138.6039120086934,"tpot_p50_ms":8.662867717892246,"tpot_p95_ms":11.106386600690334,"tpot_p99_ms":15.222634626346,"e2e_p50_ms":18087.517957988894,"e2e_p95_ms":23003.204905809245,"e2e_p99_ms":31345.921546299902,"itl_p50_ms":43.118278990732506,"itl_p95_ms":102.51104263588789,"itl_p99_ms":139.6043147338787,"validation_errors":[],"timestamp":"2026-07-18T18:12:20+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":2048,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":8.671238,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c48_i1024_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c48_i1024_o2048_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":115.91965164302383,"request_tps":2.760532795469783,"input_tps":2826.7855825610577,"output_tps":5653.571165122115,"total_tps":8480.356747683174,"mean_input_tokens":1024.0,"mean_output_tokens":2048.0,"ttft_p50_ms":288.33210151060484,"ttft_p95_ms":1272.5184718787204,"ttft_p99_ms":1444.9826379789738,"tpot_p50_ms":10.112617079387057,"tpot_p95_ms":14.458102508727643,"tpot_p99_ms":18.255647190263407,"e2e_p50_ms":21236.163742491044,"e2e_p95_ms":29887.272494437646,"e2e_p99_ms":37597.151804572204,"itl_p50_ms":50.383069028612226,"itl_p95_ms":134.48287784121928,"itl_p99_ms":147.13994598714635,"validation_errors":[],"timestamp":"2026-07-18T18:14:58+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":2048,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":14.161432,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c64_i1024_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c64_i1024_o2048_a1.log"} +{"status":"COMPLETED","completed":400,"failed":0,"duration_s":133.64104358595796,"request_tps":2.99309246072087,"input_tps":3064.926679778171,"output_tps":6129.853359556342,"total_tps":9194.780039334513,"mean_input_tokens":1024.0,"mean_output_tokens":2048.0,"ttft_p50_ms":342.8348794695921,"ttft_p95_ms":1708.2340718305204,"ttft_p99_ms":1721.9245096947998,"tpot_p50_ms":11.74577376672736,"tpot_p95_ms":16.234811524028018,"tpot_p99_ms":21.843276636524408,"e2e_p50_ms":24607.261250028387,"e2e_p95_ms":33606.11112025216,"e2e_p99_ms":45013.71039726072,"itl_p50_ms":59.94778499007225,"itl_p95_ms":136.1386915203184,"itl_p99_ms":154.8196889902465,"validation_errors":[],"timestamp":"2026-07-18T18:17:54+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":2048,"concurrency":80,"num_prompts":400,"warmup_requests":80,"attempt":1,"gain_pct":8.424449,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c80_i1024_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c80_i1024_o2048_a1.log"} +{"status":"COMPLETED","completed":480,"failed":0,"duration_s":234.856844111986,"request_tps":2.043798220209087,"input_tps":2092.8493774941053,"output_tps":4185.698754988211,"total_tps":6278.548132482316,"mean_input_tokens":1024.0,"mean_output_tokens":2048.0,"ttft_p50_ms":461.7310999892652,"ttft_p95_ms":2161.5909984480822,"ttft_p99_ms":2185.3542491368717,"tpot_p50_ms":21.325325369805896,"tpot_p95_ms":27.07574864536713,"tpot_p99_ms":35.72634585867559,"e2e_p50_ms":44672.0170500048,"e2e_p95_ms":56606.99045516085,"e2e_p99_ms":73697.05336857062,"itl_p50_ms":117.10864803171717,"itl_p95_ms":161.06074761482887,"itl_p99_ms":239.8704743001144,"validation_errors":[],"timestamp":"2026-07-18T18:22:31+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":2048,"concurrency":96,"num_prompts":480,"warmup_requests":96,"attempt":1,"gain_pct":-31.716168,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c96_i1024_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c96_i1024_o2048_a1.log"} +{"status":"COMPLETED","completed":560,"failed":0,"duration_s":265.9471658139955,"request_tps":2.1056813983558906,"input_tps":2156.217751916432,"output_tps":4312.435503832864,"total_tps":6468.653255749296,"mean_input_tokens":1024.0,"mean_output_tokens":2048.0,"ttft_p50_ms":567.68550950801,"ttft_p95_ms":6635.266994204721,"ttft_p99_ms":8276.59535565821,"tpot_p50_ms":23.480120885927953,"tpot_p95_ms":31.548404937538244,"tpot_p99_ms":39.63706408918226,"e2e_p50_ms":50113.31173099461,"e2e_p95_ms":67721.40624897437,"e2e_p99_ms":82983.10732500564,"itl_p50_ms":127.42922402685508,"itl_p95_ms":235.90965069015508,"itl_p99_ms":307.2909282532055,"validation_errors":[],"timestamp":"2026-07-18T18:27:39+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":2048,"concurrency":112,"num_prompts":560,"warmup_requests":112,"attempt":1,"gain_pct":3.027852,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c112_i1024_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c112_i1024_o2048_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":99.51119358302094,"request_tps":0.8039296597649289,"input_tps":823.2239715992872,"output_tps":3292.895886397149,"total_tps":4116.119857996436,"mean_input_tokens":1024.0,"mean_output_tokens":4096.0,"ttft_p50_ms":158.5264200111851,"ttft_p95_ms":1302.9385042289505,"ttft_p99_ms":1306.830728809,"tpot_p50_ms":4.2964961925525476,"tpot_p95_ms":5.355098602589121,"tpot_p99_ms":6.113892629041427,"e2e_p50_ms":18124.260722019244,"e2e_p95_ms":22617.89913361426,"e2e_p99_ms":25774.195665938885,"itl_p50_ms":23.189362487755716,"itl_p95_ms":24.098336059250865,"itl_p99_ms":112.00008438376246,"validation_errors":[],"timestamp":"2026-07-18T18:29:56+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":4096,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c16_i1024_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c16_i1024_o4096_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":131.9246814880171,"request_tps":1.2128132370327764,"input_tps":1241.920754721563,"output_tps":4967.683018886252,"total_tps":6209.603773607815,"mean_input_tokens":1024.0,"mean_output_tokens":4096.0,"ttft_p50_ms":183.445742004551,"ttft_p95_ms":681.2192738056183,"ttft_p99_ms":799.4718441198347,"tpot_p50_ms":5.981062579610339,"tpot_p95_ms":7.146678222012132,"tpot_p99_ms":8.669045646288014,"e2e_p50_ms":24770.314187480835,"e2e_p95_ms":29438.037315811376,"e2e_p99_ms":35937.613366589634,"itl_p50_ms":32.56895596859977,"itl_p95_ms":33.951186487684026,"itl_p99_ms":120.12839008821175,"validation_errors":[],"timestamp":"2026-07-18T18:32:46+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":4096,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":50.860616,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c32_i1024_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c32_i1024_o4096_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":181.38734522397863,"request_tps":1.323135303092098,"input_tps":1354.8905503663084,"output_tps":5419.562201465234,"total_tps":6774.452751831543,"mean_input_tokens":1024.0,"mean_output_tokens":4096.0,"ttft_p50_ms":238.64995152689517,"ttft_p95_ms":1139.7785399109125,"ttft_p99_ms":1146.5446139522828,"tpot_p50_ms":8.112716667278201,"tpot_p95_ms":9.66762623426937,"tpot_p99_ms":11.802265214443512,"e2e_p50_ms":33499.47844949202,"e2e_p95_ms":39782.468153481015,"e2e_p99_ms":48948.921489950706,"itl_p50_ms":43.284838524414226,"itl_p95_ms":47.45737180055581,"itl_p99_ms":137.7103393978905,"validation_errors":[],"timestamp":"2026-07-18T18:36:34+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":4096,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":9.096377,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c48_i1024_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c48_i1024_o4096_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":221.23040220094845,"request_tps":1.4464558072327554,"input_tps":1481.1707466063415,"output_tps":5924.682986425366,"total_tps":7405.853733031707,"mean_input_tokens":1024.0,"mean_output_tokens":4096.0,"ttft_p50_ms":329.39439499750733,"ttft_p95_ms":3896.726931768353,"ttft_p99_ms":3905.2766366972355,"tpot_p50_ms":9.72679692027142,"tpot_p95_ms":12.4468481222208,"tpot_p99_ms":15.289908936345027,"e2e_p50_ms":40192.38549200236,"e2e_p95_ms":51617.86061427265,"e2e_p99_ms":62941.447264507886,"itl_p50_ms":50.49814749509096,"itl_p95_ms":142.0402101241052,"itl_p99_ms":151.93099381169304,"validation_errors":[],"timestamp":"2026-07-18T18:41:01+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":4096,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":9.320325,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c64_i1024_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c64_i1024_o4096_a1.log"} +{"status":"COMPLETED","completed":400,"failed":0,"duration_s":263.7177618839778,"request_tps":1.5167730726305015,"input_tps":1553.1756263736336,"output_tps":6212.702505494534,"total_tps":7765.878131868169,"mean_input_tokens":1024.0,"mean_output_tokens":4096.0,"ttft_p50_ms":398.3440960291773,"ttft_p95_ms":5017.496193453553,"ttft_p99_ms":6011.088268973981,"tpot_p50_ms":11.61705385811851,"tpot_p95_ms":14.806979984381625,"tpot_p99_ms":18.76539574688816,"e2e_p50_ms":48243.98025951814,"e2e_p95_ms":61547.26277997251,"e2e_p99_ms":77199.3508402648,"itl_p50_ms":60.33314051455818,"itl_p95_ms":150.1180377672426,"itl_p99_ms":226.21734393469524,"validation_errors":[],"timestamp":"2026-07-18T18:46:10+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":4096,"concurrency":80,"num_prompts":400,"warmup_requests":80,"attempt":1,"gain_pct":4.861349,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c80_i1024_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c80_i1024_o4096_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":27.425374799000565,"request_tps":2.9170066256638854,"input_tps":11948.059138719274,"output_tps":373.3768480849773,"total_tps":12321.435986804252,"mean_input_tokens":4096.0,"mean_output_tokens":128.0,"ttft_p50_ms":2119.983285025228,"ttft_p95_ms":3708.924484558518,"ttft_p99_ms":4853.580581187853,"tpot_p50_ms":26.206653976288628,"tpot_p95_ms":40.077357259844824,"tpot_p99_ms":41.02287787677789,"e2e_p50_ms":5492.556538985809,"e2e_p95_ms":7010.689883370651,"e2e_p99_ms":7570.009939344592,"itl_p50_ms":23.41516996966675,"itl_p95_ms":586.3064015866257,"itl_p99_ms":588.1542646884918,"validation_errors":[],"timestamp":"2026-07-18T18:47:16+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":4096,"osl":128,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c16_i4096_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c16_i4096_o128_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":31.14593179000076,"request_tps":5.137107506649301,"input_tps":21041.592347235535,"output_tps":657.5497608511105,"total_tps":21699.142108086646,"mean_input_tokens":4096.0,"mean_output_tokens":128.0,"ttft_p50_ms":1123.0913799954578,"ttft_p95_ms":5076.120548369363,"ttft_p99_ms":5282.655934186187,"tpot_p50_ms":37.565049881942386,"tpot_p95_ms":73.47150537862319,"tpot_p99_ms":78.29320546922523,"e2e_p50_ms":6414.254334522411,"e2e_p95_ms":12864.456684899045,"e2e_p99_ms":14396.171578554786,"itl_p50_ms":33.182272978592664,"itl_p95_ms":589.7073245607316,"itl_p99_ms":594.1952229151502,"validation_errors":[],"timestamp":"2026-07-18T18:48:27+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":4096,"osl":128,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":76.108873,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c32_i4096_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c32_i4096_o128_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":9.767377995012794,"request_tps":8.190529745121758,"input_tps":33548.40983601872,"output_tps":2096.77561475117,"total_tps":35645.18545076989,"mean_input_tokens":4096.0,"mean_output_tokens":256.0,"ttft_p50_ms":404.3545259919483,"ttft_p95_ms":761.6440683050314,"ttft_p99_ms":765.0515972799622,"tpot_p50_ms":5.534440250930322,"tpot_p95_ms":7.702307398134256,"tpot_p99_ms":9.370647388743219,"e2e_p50_ms":1836.4145180094056,"e2e_p95_ms":2462.3718888411527,"e2e_p99_ms":2872.4470183468616,"itl_p50_ms":23.29234598437324,"itl_p95_ms":63.272292108740665,"itl_p99_ms":200.98825479857624,"validation_errors":[],"timestamp":"2026-07-18T18:49:19+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":4096,"osl":256,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c16_i4096_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c16_i4096_o256_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":14.026177330000792,"request_tps":11.407242061439913,"input_tps":46724.06348365788,"output_tps":2920.2539677286177,"total_tps":49644.3174513865,"mean_input_tokens":4096.0,"mean_output_tokens":256.0,"ttft_p50_ms":480.3931810311042,"ttft_p95_ms":1021.5871996537315,"ttft_p99_ms":1028.854544533533,"tpot_p50_ms":8.623209599903145,"tpot_p95_ms":11.907901567094227,"tpot_p99_ms":14.10560692908406,"e2e_p50_ms":2683.1415830238257,"e2e_p95_ms":3517.506742282421,"e2e_p99_ms":4132.729467479509,"itl_p50_ms":32.95586199965328,"itl_p95_ms":188.00568797159914,"itl_p99_ms":215.57805236428965,"validation_errors":[],"timestamp":"2026-07-18T18:50:12+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":4096,"osl":256,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":39.273556,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c32_i4096_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c32_i4096_o256_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":39.962241675995756,"request_tps":6.005669099993495,"input_tps":24599.220633573357,"output_tps":1537.4512895983348,"total_tps":26136.671923171692,"mean_input_tokens":4096.0,"mean_output_tokens":256.0,"ttft_p50_ms":869.7704194928519,"ttft_p95_ms":4708.243667191709,"ttft_p99_ms":6362.377203535284,"tpot_p50_ms":14.260780797956292,"tpot_p95_ms":58.81103210218533,"tpot_p99_ms":63.40879329623125,"e2e_p50_ms":4512.970490031876,"e2e_p95_ms":18159.75780230655,"e2e_p99_ms":20292.143655718537,"itl_p50_ms":43.743342510424554,"itl_p95_ms":590.8719036553521,"itl_p99_ms":596.1903882829937,"validation_errors":[],"timestamp":"2026-07-18T18:51:36+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":4096,"osl":256,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":-47.352138,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c48_i4096_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c48_i4096_o256_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":15.112249314959627,"request_tps":5.293718911903335,"input_tps":21683.07266315606,"output_tps":2710.3840828945076,"total_tps":24393.456746050568,"mean_input_tokens":4096.0,"mean_output_tokens":512.0,"ttft_p50_ms":341.2542160076555,"ttft_p95_ms":740.8906126220245,"ttft_p99_ms":744.3108330393443,"tpot_p50_ms":4.949247466758853,"tpot_p95_ms":6.783718762975349,"tpot_p99_ms":7.330311153005667,"e2e_p50_ms":2791.9111874944065,"e2e_p95_ms":3728.274607143248,"e2e_p99_ms":4091.023182893987,"itl_p50_ms":23.276783991605043,"itl_p95_ms":54.888494743499905,"itl_p99_ms":186.4983381028287,"validation_errors":[],"timestamp":"2026-07-18T18:52:29+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":4096,"osl":512,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c16_i4096_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c16_i4096_o512_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":21.911108853004407,"request_tps":7.3022319898730785,"input_tps":29909.94223052013,"output_tps":3738.742778815016,"total_tps":33648.685009335146,"mean_input_tokens":4096.0,"mean_output_tokens":512.0,"ttft_p50_ms":379.49016501079313,"ttft_p95_ms":1075.023136442178,"ttft_p99_ms":1082.154741427512,"tpot_p50_ms":7.3359354687107405,"tpot_p95_ms":9.920991471489714,"tpot_p99_ms":10.79004802109711,"e2e_p50_ms":4229.466620483436,"e2e_p95_ms":5475.686906414921,"e2e_p99_ms":5945.379423882695,"itl_p50_ms":32.797985477373004,"itl_p95_ms":146.72026433108837,"itl_p99_ms":192.44901689933613,"validation_errors":[],"timestamp":"2026-07-18T18:53:31+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":4096,"osl":512,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":37.941438,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c32_i4096_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c32_i4096_o512_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":29.003836949996185,"request_tps":8.27476724592577,"input_tps":33893.44663931195,"output_tps":4236.680829913994,"total_tps":38130.12746922595,"mean_input_tokens":4096.0,"mean_output_tokens":512.0,"ttft_p50_ms":426.41167898545973,"ttft_p95_ms":1375.225903527462,"ttft_p99_ms":1382.2503613162553,"tpot_p50_ms":9.75442425934042,"tpot_p95_ms":12.282099402413944,"tpot_p99_ms":13.23250507786888,"e2e_p50_ms":5502.053612988675,"e2e_p95_ms":6894.145544318598,"e2e_p99_ms":7216.558822122751,"itl_p50_ms":43.59483998268843,"itl_p95_ms":161.77467399975285,"itl_p99_ms":209.39631973742513,"validation_errors":[],"timestamp":"2026-07-18T18:54:40+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":4096,"osl":512,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":13.318329,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c48_i4096_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c48_i4096_o512_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":57.404433197982144,"request_tps":5.57448235568065,"input_tps":22833.079728867942,"output_tps":2854.134966108493,"total_tps":25687.214694976436,"mean_input_tokens":4096.0,"mean_output_tokens":512.0,"ttft_p50_ms":558.2840470015071,"ttft_p95_ms":4132.301608248963,"ttft_p99_ms":5322.386830972391,"tpot_p50_ms":14.233595573326479,"tpot_p95_ms":43.420643586603425,"tpot_p99_ms":48.219126795019655,"e2e_p50_ms":8070.988351973938,"e2e_p95_ms":23673.498982322053,"e2e_p99_ms":25400.564198437496,"itl_p50_ms":51.005691988393664,"itl_p95_ms":586.2208275357261,"itl_p99_ms":593.2496621797327,"validation_errors":[],"timestamp":"2026-07-18T18:56:21+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":4096,"osl":512,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":-32.632759,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c64_i4096_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c64_i4096_o512_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":25.514679734013043,"request_tps":3.135449899194847,"input_tps":12842.802787102093,"output_tps":3210.7006967755233,"total_tps":16053.503483877616,"mean_input_tokens":4096.0,"mean_output_tokens":1024.0,"ttft_p50_ms":165.63894698629156,"ttft_p95_ms":589.2183909745654,"ttft_p99_ms":768.9141870109597,"tpot_p50_ms":4.525245156390401,"tpot_p95_ms":5.793248487985579,"tpot_p99_ms":5.819416314345613,"e2e_p50_ms":4858.849231997738,"e2e_p95_ms":6090.760670043528,"e2e_p99_ms":6228.097616977174,"itl_p50_ms":23.231276019942015,"itl_p95_ms":52.112919196952134,"itl_p99_ms":66.77060267189516,"validation_errors":[],"timestamp":"2026-07-18T18:57:27+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":4096,"osl":1024,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c16_i4096_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c16_i4096_o1024_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":36.91141141200205,"request_tps":4.334702843359024,"input_tps":17754.94284639856,"output_tps":4438.73571159964,"total_tps":22193.6785579982,"mean_input_tokens":4096.0,"mean_output_tokens":1024.0,"ttft_p50_ms":273.89866948942654,"ttft_p95_ms":1002.4809360125802,"ttft_p99_ms":1010.1936360367107,"tpot_p50_ms":6.3972054824052345,"tpot_p95_ms":8.129353132245143,"tpot_p99_ms":9.535079347232026,"e2e_p50_ms":6971.648895996623,"e2e_p95_ms":8857.092230775743,"e2e_p99_ms":10015.468355586634,"itl_p50_ms":32.80700449249707,"itl_p95_ms":62.69785108452196,"itl_p99_ms":183.55950890283566,"validation_errors":[],"timestamp":"2026-07-18T18:58:43+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":4096,"osl":1024,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":38.248193,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c32_i4096_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c32_i4096_o1024_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":51.129327343951445,"request_tps":4.693979218335869,"input_tps":19226.53887830372,"output_tps":4806.63471957593,"total_tps":24033.173597879653,"mean_input_tokens":4096.0,"mean_output_tokens":1024.0,"ttft_p50_ms":324.1900310094934,"ttft_p95_ms":1428.8913666125154,"ttft_p99_ms":1437.3429323435994,"tpot_p50_ms":9.029031756593694,"tpot_p95_ms":11.14270064686705,"tpot_p99_ms":12.344963765219036,"e2e_p50_ms":9709.469172521494,"e2e_p95_ms":12204.79668988264,"e2e_p99_ms":13453.353839059702,"itl_p50_ms":43.55809302069247,"itl_p95_ms":128.18831661716104,"itl_p99_ms":183.49439012818075,"validation_errors":[],"timestamp":"2026-07-18T19:00:17+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":4096,"osl":1024,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":8.288374,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c48_i4096_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c48_i4096_o1024_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":82.76903226703871,"request_tps":3.8661802758256276,"input_tps":15835.87440978177,"output_tps":3958.9686024454427,"total_tps":19794.843012227215,"mean_input_tokens":4096.0,"mean_output_tokens":1024.0,"ttft_p50_ms":518.7387884943746,"ttft_p95_ms":2357.0347616361687,"ttft_p99_ms":2957.4765696551185,"tpot_p50_ms":11.952111313282488,"tpot_p95_ms":27.62270944424812,"tpot_p99_ms":29.84741888837745,"e2e_p50_ms":12878.682588489028,"e2e_p95_ms":29152.795300711296,"e2e_p99_ms":31005.86878995411,"itl_p50_ms":50.825793005060405,"itl_p95_ms":368.05234247585753,"itl_p99_ms":588.7268053076696,"validation_errors":[],"timestamp":"2026-07-18T19:02:20+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":4096,"osl":1024,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":-17.635335,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c64_i4096_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c64_i4096_o1024_a1.log"} +{"status":"COMPLETED","completed":400,"failed":0,"duration_s":91.65950127399992,"request_tps":4.363977486679428,"input_tps":17874.851785438936,"output_tps":4468.712946359734,"total_tps":22343.56473179867,"mean_input_tokens":4096.0,"mean_output_tokens":1024.0,"ttft_p50_ms":524.5373310171999,"ttft_p95_ms":3537.0907241274836,"ttft_p99_ms":4141.6724040027475,"tpot_p50_ms":13.496875216510059,"tpot_p95_ms":30.963916273128483,"tpot_p99_ms":33.57338338814272,"e2e_p50_ms":14529.212655004812,"e2e_p95_ms":32501.086077894433,"e2e_p99_ms":35108.48874574003,"itl_p50_ms":60.96756397164427,"itl_p95_ms":374.5441255479817,"itl_p99_ms":592.4875863245687,"validation_errors":[],"timestamp":"2026-07-18T19:04:35+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":4096,"osl":1024,"concurrency":80,"num_prompts":400,"warmup_requests":80,"attempt":1,"gain_pct":12.875685,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c80_i4096_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c80_i4096_o1024_a1.log"} +{"status":"COMPLETED","completed":480,"failed":0,"duration_s":142.38683148298878,"request_tps":3.371098260988738,"input_tps":13808.018477009871,"output_tps":3452.004619252468,"total_tps":17260.02309626234,"mean_input_tokens":4096.0,"mean_output_tokens":1024.0,"ttft_p50_ms":526.5267349896021,"ttft_p95_ms":2304.5736913307337,"ttft_p99_ms":3144.520140812383,"tpot_p50_ms":24.322228707715222,"tpot_p95_ms":40.228325636617704,"tpot_p99_ms":43.51425614760753,"e2e_p50_ms":26297.34238947276,"e2e_p95_ms":41555.37309341016,"e2e_p99_ms":44915.08248507217,"itl_p50_ms":122.315547458129,"itl_p95_ms":383.49426267959643,"itl_p99_ms":594.4165730790701,"validation_errors":[],"timestamp":"2026-07-18T19:07:37+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":4096,"osl":1024,"concurrency":96,"num_prompts":480,"warmup_requests":96,"attempt":1,"gain_pct":-22.751704,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c96_i4096_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c96_i4096_o1024_a1.log"} +{"status":"COMPLETED","completed":560,"failed":0,"duration_s":253.12693027500063,"request_tps":2.212328808284477,"input_tps":9061.698798733218,"output_tps":2265.4246996833044,"total_tps":11327.123498416522,"mean_input_tokens":4096.0,"mean_output_tokens":1024.0,"ttft_p50_ms":2959.015224536415,"ttft_p95_ms":14808.80964785756,"ttft_p99_ms":15408.738555365126,"tpot_p50_ms":45.0284924178727,"tpot_p95_ms":58.39624878956277,"tpot_p99_ms":63.82438660657155,"e2e_p50_ms":50792.843289498705,"e2e_p95_ms":66813.83393136784,"e2e_p99_ms":74134.63194476954,"itl_p50_ms":132.14688701555133,"itl_p95_ms":597.5305522850249,"itl_p99_ms":603.0753915465903,"validation_errors":[],"timestamp":"2026-07-18T19:12:37+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":4096,"osl":1024,"concurrency":112,"num_prompts":560,"warmup_requests":112,"attempt":1,"gain_pct":-34.373648,"plateau_streak":2,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c112_i4096_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c112_i4096_o1024_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":69.5558072910062,"request_tps":1.150155581766129,"input_tps":4711.037262914065,"output_tps":2355.5186314570324,"total_tps":7066.555894371097,"mean_input_tokens":4096.0,"mean_output_tokens":2048.0,"ttft_p50_ms":715.6742635124829,"ttft_p95_ms":3713.4023565449734,"ttft_p99_ms":4850.491353920079,"tpot_p50_ms":5.915739182221876,"tpot_p95_ms":8.307932760485375,"tpot_p99_ms":8.989809165319095,"e2e_p50_ms":13176.228364522103,"e2e_p95_ms":18257.04116918496,"e2e_p99_ms":19131.753241540864,"itl_p50_ms":23.246793483849615,"itl_p95_ms":26.27411835419479,"itl_p99_ms":346.80464689969085,"validation_errors":[],"timestamp":"2026-07-18T19:14:29+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":4096,"osl":2048,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c16_i4096_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c16_i4096_o2048_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":89.59305808303179,"request_tps":1.7858526477767669,"input_tps":7314.852445293637,"output_tps":3657.4262226468186,"total_tps":10972.278667940456,"mean_input_tokens":4096.0,"mean_output_tokens":2048.0,"ttft_p50_ms":450.76618646271527,"ttft_p95_ms":1067.1620750421425,"ttft_p99_ms":1196.5555062942433,"tpot_p50_ms":8.26629054909547,"tpot_p95_ms":11.940568466856208,"tpot_p99_ms":12.573352379889423,"e2e_p50_ms":17325.67453000229,"e2e_p95_ms":25194.91269569262,"e2e_p99_ms":26312.33389854722,"itl_p50_ms":32.74544602027163,"itl_p95_ms":62.29216982610523,"itl_p99_ms":356.08389927307144,"validation_errors":[],"timestamp":"2026-07-18T19:16:43+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":4096,"osl":2048,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":55.270528,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c32_i4096_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c32_i4096_o2048_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":112.12849703099346,"request_tps":2.140401471123452,"input_tps":8767.08442572166,"output_tps":4383.54221286083,"total_tps":13150.626638582487,"mean_input_tokens":4096.0,"mean_output_tokens":2048.0,"ttft_p50_ms":491.57543847104535,"ttft_p95_ms":1363.1146168918349,"ttft_p99_ms":1430.2133600180966,"tpot_p50_ms":9.406217177829928,"tpot_p95_ms":15.264934854737266,"tpot_p99_ms":17.10854997118936,"e2e_p50_ms":19881.104399013566,"e2e_p95_ms":32186.65185423451,"e2e_p99_ms":35875.92816842485,"itl_p50_ms":43.557636032346636,"itl_p95_ms":121.23903800966218,"itl_p99_ms":367.5389637879562,"validation_errors":[],"timestamp":"2026-07-18T19:19:18+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":4096,"osl":2048,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":19.853196,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c48_i4096_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c48_i4096_o2048_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":129.61862288200064,"request_tps":2.4687810507855388,"input_tps":10112.127184017567,"output_tps":5056.063592008783,"total_tps":15168.19077602635,"mean_input_tokens":4096.0,"mean_output_tokens":2048.0,"ttft_p50_ms":470.98066701437347,"ttft_p95_ms":1742.757058312418,"ttft_p99_ms":1828.1481806514785,"tpot_p50_ms":10.569861299456354,"tpot_p95_ms":18.716720150581256,"tpot_p99_ms":19.90702731983894,"e2e_p50_ms":22392.64341397211,"e2e_p95_ms":38859.03114021349,"e2e_p99_ms":41717.85786306079,"itl_p50_ms":50.843718490796164,"itl_p95_ms":134.92749962024388,"itl_p99_ms":432.4927327746921,"validation_errors":[],"timestamp":"2026-07-18T19:22:16+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":4096,"osl":2048,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":15.341962,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c64_i4096_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c64_i4096_o2048_a1.log"} +{"status":"COMPLETED","completed":400,"failed":0,"duration_s":238.04548150801565,"request_tps":1.6803511558631743,"input_tps":6882.718334415562,"output_tps":3441.359167207781,"total_tps":10324.077501623344,"mean_input_tokens":4096.0,"mean_output_tokens":2048.0,"ttft_p50_ms":1406.780143006472,"ttft_p95_ms":19549.337616140838,"ttft_p99_ms":24283.225379711363,"tpot_p50_ms":20.73578801540156,"tpot_p95_ms":28.220994367163716,"tpot_p99_ms":30.849816763446427,"e2e_p50_ms":44784.202012990136,"e2e_p95_ms":65557.0898910897,"e2e_p99_ms":71729.3466035649,"itl_p50_ms":60.96435050130822,"itl_p95_ms":583.7088280677563,"itl_p99_ms":594.1895397379994,"validation_errors":[],"timestamp":"2026-07-18T19:26:58+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":4096,"osl":2048,"concurrency":80,"num_prompts":400,"warmup_requests":80,"attempt":1,"gain_pct":-31.935999,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c80_i4096_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c80_i4096_o2048_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":112.01463652402163,"request_tps":0.7141923813040624,"input_tps":2925.3319938214395,"output_tps":2925.3319938214395,"total_tps":5850.663987642879,"mean_input_tokens":4096.0,"mean_output_tokens":4096.0,"ttft_p50_ms":421.53731649159454,"ttft_p95_ms":3712.767628041909,"ttft_p99_ms":4857.323146451381,"tpot_p50_ms":5.0191683680008445,"tpot_p95_ms":6.352055243234791,"tpot_p99_ms":6.773388297911828,"e2e_p50_ms":21208.920968987513,"e2e_p95_ms":27438.232696504565,"e2e_p99_ms":28769.643190655624,"itl_p50_ms":23.22822203859687,"itl_p95_ms":24.519962957128882,"itl_p99_ms":345.6738684209995,"validation_errors":[],"timestamp":"2026-07-18T19:29:30+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":4096,"osl":4096,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c16_i4096_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c16_i4096_o4096_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":149.55050380295143,"request_tps":1.0698726913739915,"input_tps":4382.198543867869,"output_tps":4382.198543867869,"total_tps":8764.397087735739,"mean_input_tokens":4096.0,"mean_output_tokens":4096.0,"ttft_p50_ms":450.79027648898773,"ttft_p95_ms":1028.4254888480061,"ttft_p99_ms":1045.0533951708346,"tpot_p50_ms":7.050545422587161,"tpot_p95_ms":9.074772135432758,"tpot_p99_ms":9.533232284069172,"e2e_p50_ms":29222.459610493388,"e2e_p95_ms":37626.648101734456,"e2e_p99_ms":39502.80079207965,"itl_p50_ms":32.77105049346574,"itl_p95_ms":35.29650761338416,"itl_p99_ms":354.44341631373396,"validation_errors":[],"timestamp":"2026-07-18T19:32:39+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":4096,"osl":4096,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":49.801751,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c32_i4096_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c32_i4096_o4096_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":223.02939985098783,"request_tps":1.076091314240861,"input_tps":4407.670023130567,"output_tps":4407.670023130567,"total_tps":8815.340046261133,"mean_input_tokens":4096.0,"mean_output_tokens":4096.0,"ttft_p50_ms":786.707060498884,"ttft_p95_ms":2421.0900381382075,"ttft_p99_ms":4742.584304185,"tpot_p50_ms":10.352853906223771,"tpot_p95_ms":12.940914454640792,"tpot_p99_ms":13.753661776530942,"e2e_p50_ms":43480.46249651816,"e2e_p95_ms":54127.80561833059,"e2e_p99_ms":57988.662274379734,"itl_p50_ms":43.60076901502907,"itl_p95_ms":52.6284234219929,"itl_p99_ms":369.43381873308675,"validation_errors":[],"timestamp":"2026-07-18T19:37:11+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":4096,"osl":4096,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":0.581249,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c48_i4096_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c48_i4096_o4096_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":290.6847050730139,"request_tps":1.1008491138865484,"input_tps":4509.077970479302,"output_tps":4509.077970479302,"total_tps":9018.155940958604,"mean_input_tokens":4096.0,"mean_output_tokens":4096.0,"ttft_p50_ms":833.2723155035637,"ttft_p95_ms":15451.517193226027,"ttft_p99_ms":19573.726564612007,"tpot_p50_ms":12.888698351277512,"tpot_p95_ms":16.689547016021688,"tpot_p99_ms":17.56533690563176,"e2e_p50_ms":54958.61821301514,"e2e_p95_ms":72943.05852844554,"e2e_p99_ms":79202.48965330189,"itl_p50_ms":50.78450101427734,"itl_p95_ms":367.5524547026725,"itl_p99_ms":582.9529409989482,"validation_errors":[],"timestamp":"2026-07-18T19:42:52+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":4096,"osl":4096,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":2.300715,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c64_i4096_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c64_i4096_o4096_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":52.62665926601039,"request_tps":1.5201420936796768,"input_tps":12453.004031423912,"output_tps":194.57818799099863,"total_tps":12647.582219414911,"mean_input_tokens":8192.0,"mean_output_tokens":128.0,"ttft_p50_ms":3649.2556575103663,"ttft_p95_ms":7405.48684663954,"ttft_p99_ms":9317.749860499167,"tpot_p50_ms":54.28923681097868,"tpot_p95_ms":76.63595826206014,"tpot_p99_ms":77.81631357828981,"e2e_p50_ms":10576.572170015424,"e2e_p95_ms":15007.506803589058,"e2e_p99_ms":16221.34910881983,"itl_p50_ms":70.57916303165257,"itl_p95_ms":604.4011024641804,"itl_p99_ms":608.7619225145318,"validation_errors":[],"timestamp":"2026-07-18T19:44:29+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":8192,"osl":128,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c16_i8192_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c16_i8192_o128_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":4.795969402999617,"request_tps":8.340336778416932,"input_tps":68324.0388887915,"output_tps":1067.5631076373672,"total_tps":69391.60199642887,"mean_input_tokens":8192.0,"mean_output_tokens":128.0,"ttft_p50_ms":441.06454349821433,"ttft_p95_ms":660.0064453639789,"ttft_p99_ms":676.0541587107581,"tpot_p50_ms":3.4878826340363456,"tpot_p95_ms":6.366497862008839,"tpot_p99_ms":6.9078455790354845,"e2e_p50_ms":950.9154905099422,"e2e_p95_ms":1044.0201687393708,"e2e_p99_ms":1076.5330482751597,"itl_p50_ms":16.91690896404907,"itl_p95_ms":53.69745850330218,"itl_p99_ms":211.1273896228522,"validation_errors":[],"timestamp":"2026-07-18T19:45:13+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":8192,"osl":128,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c8_i8192_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c8_i8192_o128_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":9.872122569009662,"request_tps":8.103627101544925,"input_tps":66384.91321585602,"output_tps":2074.5285379955008,"total_tps":68459.44175385153,"mean_input_tokens":8192.0,"mean_output_tokens":256.0,"ttft_p50_ms":557.1600714756642,"ttft_p95_ms":774.8870775423711,"ttft_p99_ms":784.6547809574986,"tpot_p50_ms":4.98190056475555,"tpot_p95_ms":7.450186407430936,"tpot_p99_ms":9.465973456175607,"e2e_p50_ms":1875.592467491515,"e2e_p95_ms":2478.053189397906,"e2e_p99_ms":2933.1205807079023,"itl_p50_ms":23.436056973878294,"itl_p95_ms":60.76410271052736,"itl_p99_ms":192.79060522036158,"validation_errors":[],"timestamp":"2026-07-18T19:46:03+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":8192,"osl":256,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c16_i8192_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c16_i8192_o256_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":61.00367025798187,"request_tps":2.622793011033057,"input_tps":21485.9203463828,"output_tps":671.4350108244626,"total_tps":22157.355357207263,"mean_input_tokens":8192.0,"mean_output_tokens":256.0,"ttft_p50_ms":1223.253781470703,"ttft_p95_ms":9618.67946901184,"ttft_p99_ms":10224.895033486537,"tpot_p50_ms":41.25895330775986,"tpot_p95_ms":76.81204658310956,"tpot_p99_ms":84.05319400788649,"e2e_p50_ms":12035.44781851815,"e2e_p95_ms":27617.004872500547,"e2e_p99_ms":29664.781875374607,"itl_p50_ms":33.52173799066804,"itl_p95_ms":607.2569229902001,"itl_p99_ms":613.2081511156866,"validation_errors":[],"timestamp":"2026-07-18T19:47:41+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":8192,"osl":256,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":-67.634332,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c32_i8192_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c32_i8192_o256_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":15.593216129986104,"request_tps":5.130436167440673,"input_tps":42028.533083673996,"output_tps":2626.7833177296247,"total_tps":44655.31640140362,"mean_input_tokens":8192.0,"mean_output_tokens":512.0,"ttft_p50_ms":422.982416494051,"ttft_p95_ms":754.0211776038632,"ttft_p99_ms":762.2867310652508,"tpot_p50_ms":5.037861322875202,"tpot_p95_ms":7.1634147765931395,"tpot_p99_ms":7.989075208881754,"e2e_p50_ms":2998.166728502838,"e2e_p95_ms":4203.896858173539,"e2e_p99_ms":4399.0141509403475,"itl_p50_ms":23.450924520147964,"itl_p95_ms":58.802504040067994,"itl_p99_ms":190.17607445304745,"validation_errors":[],"timestamp":"2026-07-18T19:48:35+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":8192,"osl":512,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c16_i8192_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c16_i8192_o512_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":22.35739110398572,"request_tps":7.156470057522781,"input_tps":58625.80271122662,"output_tps":3664.112669451664,"total_tps":62289.915380678285,"mean_input_tokens":8192.0,"mean_output_tokens":512.0,"ttft_p50_ms":455.6813695235178,"ttft_p95_ms":1204.0263380418762,"ttft_p99_ms":1212.5714486971265,"tpot_p50_ms":7.182250016652788,"tpot_p95_ms":9.132561444742516,"tpot_p99_ms":10.276235864519817,"e2e_p50_ms":4159.535837476142,"e2e_p95_ms":5234.324087054118,"e2e_p99_ms":5631.671186165767,"itl_p50_ms":33.29819001373835,"itl_p95_ms":124.02627501578532,"itl_p99_ms":200.9082673455123,"validation_errors":[],"timestamp":"2026-07-18T19:49:41+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":8192,"osl":512,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":39.49048,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c32_i8192_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c32_i8192_o512_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":77.15698670299025,"request_tps":3.1105413813509997,"input_tps":25481.55499602739,"output_tps":1592.5971872517118,"total_tps":27074.1521832791,"mean_input_tokens":8192.0,"mean_output_tokens":512.0,"ttft_p50_ms":843.5605024860706,"ttft_p95_ms":10878.779719574948,"ttft_p99_ms":14507.478715686011,"tpot_p50_ms":12.297772751495046,"tpot_p95_ms":62.26652737354578,"tpot_p99_ms":69.26673880495412,"e2e_p50_ms":7184.469061496202,"e2e_p95_ms":41874.87056192185,"e2e_p99_ms":45867.37467469472,"itl_p50_ms":44.450740970205516,"itl_p95_ms":605.3924127831124,"itl_p99_ms":612.2382667893544,"validation_errors":[],"timestamp":"2026-07-18T19:51:39+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":8192,"osl":512,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":-56.535256,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c48_i8192_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c48_i8192_o512_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":25.968494047992863,"request_tps":3.080656115527935,"input_tps":25236.734898404844,"output_tps":3154.5918623006055,"total_tps":28391.32676070545,"mean_input_tokens":8192.0,"mean_output_tokens":1024.0,"ttft_p50_ms":259.02811298146844,"ttft_p95_ms":826.4075160259381,"ttft_p99_ms":877.568164485856,"tpot_p50_ms":4.4949620786666475,"tpot_p95_ms":5.786530351950646,"tpot_p99_ms":5.992255869585762,"e2e_p50_ms":4911.320575483842,"e2e_p95_ms":6181.0830005735625,"e2e_p99_ms":6552.442917730077,"itl_p50_ms":23.498331021983176,"itl_p95_ms":35.700679733417836,"itl_p99_ms":84.83625080203626,"validation_errors":[],"timestamp":"2026-07-18T19:52:49+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":8192,"osl":1024,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c16_i8192_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c16_i8192_o1024_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":55.81729058502242,"request_tps":2.866495279921974,"input_tps":23482.32933312081,"output_tps":2935.2911666401014,"total_tps":26417.620499760913,"mean_input_tokens":8192.0,"mean_output_tokens":1024.0,"ttft_p50_ms":432.61903247912414,"ttft_p95_ms":2392.2370521439007,"ttft_p99_ms":3045.801051919698,"tpot_p50_ms":7.2689190430007695,"tpot_p95_ms":21.658628278668306,"tpot_p99_ms":24.529323427134965,"e2e_p50_ms":7964.994051493704,"e2e_p95_ms":24122.005968986192,"e2e_p99_ms":25714.288117977558,"itl_p50_ms":33.2991530012805,"itl_p95_ms":134.62587096146302,"itl_p99_ms":602.2263226815267,"validation_errors":[],"timestamp":"2026-07-18T19:54:27+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":8192,"osl":1024,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":-6.951793,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c32_i8192_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c32_i8192_o1024_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":98.57099127897527,"request_tps":2.4347934101702684,"input_tps":19945.82761611484,"output_tps":2493.228452014355,"total_tps":22439.056068129194,"mean_input_tokens":8192.0,"mean_output_tokens":1024.0,"ttft_p50_ms":835.9180600091349,"ttft_p95_ms":3756.3087993330473,"ttft_p99_ms":4235.631664223038,"tpot_p50_ms":11.14800649072396,"tpot_p95_ms":35.99176794224084,"tpot_p99_ms":43.3315398966252,"e2e_p50_ms":12652.750771521823,"e2e_p95_ms":39178.519853984464,"e2e_p99_ms":48125.428713074616,"itl_p50_ms":44.341744971461594,"itl_p95_ms":600.3380594454939,"itl_p99_ms":608.8208751170896,"validation_errors":[],"timestamp":"2026-07-18T19:56:49+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":8192,"osl":1024,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":-15.060268,"plateau_streak":2,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c48_i8192_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c48_i8192_o1024_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":75.94102492200909,"request_tps":1.0534490426243186,"input_tps":8629.854557178418,"output_tps":2157.4636392946045,"total_tps":10787.318196473023,"mean_input_tokens":8192.0,"mean_output_tokens":2048.0,"ttft_p50_ms":783.5188799945172,"ttft_p95_ms":2520.781560466275,"ttft_p99_ms":3006.1994034703816,"tpot_p50_ms":7.009607913047298,"tpot_p95_ms":10.662727685097893,"tpot_p99_ms":11.41829209046445,"e2e_p50_ms":15648.693028022535,"e2e_p95_ms":22613.289505196735,"e2e_p99_ms":24663.759748991568,"itl_p50_ms":23.467471008189023,"itl_p95_ms":30.495665885973718,"itl_p99_ms":591.7937021364924,"validation_errors":[],"timestamp":"2026-07-18T19:58:44+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":8192,"osl":2048,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c16_i8192_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c16_i8192_o2048_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":115.00693737500114,"request_tps":1.3912204224540885,"input_tps":11396.877700743893,"output_tps":2849.2194251859733,"total_tps":14246.097125929868,"mean_input_tokens":8192.0,"mean_output_tokens":2048.0,"ttft_p50_ms":835.9772419789806,"ttft_p95_ms":2066.2841667799507,"ttft_p99_ms":2286.0336735850424,"tpot_p50_ms":10.668069699800878,"tpot_p95_ms":17.981925462449663,"tpot_p99_ms":18.53090740557316,"e2e_p50_ms":22035.366005497053,"e2e_p95_ms":37844.62743238546,"e2e_p99_ms":39225.9671297617,"itl_p50_ms":33.25802995823324,"itl_p95_ms":141.47482322878196,"itl_p99_ms":597.9060179169755,"validation_errors":[],"timestamp":"2026-07-18T20:01:22+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":8192,"osl":2048,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":32.063381,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c32_i8192_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c32_i8192_o2048_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":232.01551965501858,"request_tps":1.0344135614585328,"input_tps":8473.9158954683,"output_tps":2118.478973867075,"total_tps":10592.394869335376,"mean_input_tokens":8192.0,"mean_output_tokens":2048.0,"ttft_p50_ms":1947.0159135235008,"ttft_p95_ms":23010.89034444302,"ttft_p99_ms":29372.45231100066,"tpot_p50_ms":20.233403723014714,"tpot_p95_ms":26.8060361781375,"tpot_p99_ms":28.558197845022963,"e2e_p50_ms":45023.77605653601,"e2e_p95_ms":68090.8630363876,"e2e_p99_ms":75688.56236802587,"itl_p50_ms":44.29638898000121,"itl_p95_ms":599.8584185144864,"itl_p99_ms":609.5215430890676,"validation_errors":[],"timestamp":"2026-07-18T20:05:59+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":8192,"osl":2048,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":-25.64704,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c48_i8192_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c48_i8192_o2048_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":138.11054792703362,"request_tps":0.5792461271116345,"input_tps":4745.18427329851,"output_tps":2372.592136649255,"total_tps":7117.7764099477645,"mean_input_tokens":8192.0,"mean_output_tokens":4096.0,"ttft_p50_ms":802.360145986313,"ttft_p95_ms":7390.702065741059,"ttft_p99_ms":9303.993943634556,"tpot_p50_ms":5.980285578515376,"tpot_p95_ms":7.965164925683896,"tpot_p99_ms":8.704633864639375,"e2e_p50_ms":26579.255759483203,"e2e_p95_ms":35896.03194551018,"e2e_p99_ms":37329.36212315689,"itl_p50_ms":23.447806015610695,"itl_p95_ms":27.74131908663547,"itl_p99_ms":589.9782666948158,"validation_errors":[],"timestamp":"2026-07-18T20:08:57+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":8192,"osl":4096,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c16_i8192_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c16_i8192_o4096_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":66.27285723999375,"request_tps":0.6035653458420857,"input_tps":4944.407313138366,"output_tps":2472.203656569183,"total_tps":7416.610969707548,"mean_input_tokens":8192.0,"mean_output_tokens":4096.0,"ttft_p50_ms":154.33960853260942,"ttft_p95_ms":522.6384704496013,"ttft_p99_ms":528.825676512206,"tpot_p50_ms":3.0868320973116394,"tpot_p95_ms":3.4866866768907494,"tpot_p99_ms":3.566206874839719,"e2e_p50_ms":12793.104932963615,"e2e_p95_ms":14430.330305808455,"e2e_p99_ms":14772.096034992719,"itl_p50_ms":17.08072901237756,"itl_p95_ms":17.6163325086236,"itl_p99_ms":24.355617526452953,"validation_errors":[],"timestamp":"2026-07-18T20:10:47+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":8192,"osl":4096,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c8_i8192_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c8_i8192_o4096_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":32.85589941800572,"request_tps":2.4348747536084288,"input_tps":39892.9879631205,"output_tps":311.6639684618789,"total_tps":40204.651931582375,"mean_input_tokens":16384.0,"mean_output_tokens":128.0,"ttft_p50_ms":3317.6310474809725,"ttft_p95_ms":5706.366731255548,"ttft_p99_ms":5840.354530965559,"tpot_p50_ms":24.15993261425096,"tpot_p95_ms":46.016855838279575,"tpot_p99_ms":51.24819071268595,"e2e_p50_ms":6425.384781032335,"e2e_p95_ms":8097.336720325984,"e2e_p99_ms":9742.034361217497,"itl_p50_ms":23.801227973308414,"itl_p95_ms":639.8789892322384,"itl_p99_ms":649.9606221797876,"validation_errors":[],"timestamp":"2026-07-18T20:12:00+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":16384,"osl":128,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c16_i16384_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c16_i16384_o128_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":5.252103206992615,"request_tps":7.615996568145171,"input_tps":124780.48777249048,"output_tps":974.8475607225819,"total_tps":125755.33533321305,"mean_input_tokens":16384.0,"mean_output_tokens":128.0,"ttft_p50_ms":457.6253739942331,"ttft_p95_ms":716.4895470225018,"ttft_p99_ms":775.2489467541454,"tpot_p50_ms":4.488874964716691,"tpot_p95_ms":6.4900362901490425,"tpot_p99_ms":6.787161545000244,"e2e_p50_ms":1043.0409155087546,"e2e_p95_ms":1136.3341309537643,"e2e_p99_ms":1375.3265697881577,"itl_p50_ms":17.073608993086964,"itl_p95_ms":66.31515600020066,"itl_p99_ms":218.6686130007729,"validation_errors":[],"timestamp":"2026-07-18T20:12:43+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":16384,"osl":128,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c8_i16384_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c8_i16384_o128_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":10.506884620990604,"request_tps":7.614055249086525,"input_tps":124748.68120103363,"output_tps":1949.1981437661505,"total_tps":126697.87934479979,"mean_input_tokens":16384.0,"mean_output_tokens":256.0,"ttft_p50_ms":743.1433930178173,"ttft_p95_ms":1167.003435062361,"ttft_p99_ms":1172.2243746306049,"tpot_p50_ms":4.975201550862003,"tpot_p95_ms":7.124236926902085,"tpot_p99_ms":8.258289211635082,"e2e_p50_ms":2030.9587569790892,"e2e_p95_ms":2267.727230367018,"e2e_p99_ms":2652.351713720122,"itl_p50_ms":23.812946485122666,"itl_p95_ms":65.12235866975969,"itl_p99_ms":226.23721632175145,"validation_errors":[],"timestamp":"2026-07-18T20:13:31+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":16384,"osl":256,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c16_i16384_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c16_i16384_o256_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":114.76059845497366,"request_tps":1.3942067412865229,"input_tps":22842.68324923839,"output_tps":356.91692576934986,"total_tps":23199.60017500774,"mean_input_tokens":16384.0,"mean_output_tokens":256.0,"ttft_p50_ms":1923.889297991991,"ttft_p95_ms":19711.050636696746,"ttft_p99_ms":21195.523934935918,"tpot_p50_ms":81.72852586664936,"tpot_p95_ms":115.77943385533037,"tpot_p99_ms":120.72493027551465,"e2e_p50_ms":23706.804453540826,"e2e_p95_ms":47421.27299700223,"e2e_p99_ms":50713.6661581439,"itl_p50_ms":267.4672239809297,"itl_p95_ms":636.3478260987904,"itl_p99_ms":646.8768658931367,"validation_errors":[],"timestamp":"2026-07-18T20:16:11+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":16384,"osl":256,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":-81.689038,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c32_i16384_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c32_i16384_o256_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":112.98893994098762,"request_tps":0.7080339017410268,"input_tps":11600.427446124982,"output_tps":362.5133576914057,"total_tps":11962.940803816387,"mean_input_tokens":16384.0,"mean_output_tokens":512.0,"ttft_p50_ms":4437.274319498101,"ttft_p95_ms":14985.202160920013,"ttft_p99_ms":18895.70502366113,"tpot_p50_ms":33.29202425539714,"tpot_p95_ms":45.05823920732077,"tpot_p99_ms":49.4274291818744,"e2e_p50_ms":22435.763743997086,"e2e_p95_ms":35552.10958417738,"e2e_p99_ms":39551.044102405416,"itl_p50_ms":23.937391466461122,"itl_p95_ms":625.7099879381713,"itl_p99_ms":638.5121999442343,"validation_errors":[],"timestamp":"2026-07-18T20:18:49+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":16384,"osl":512,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c16_i16384_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c16_i16384_o512_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":58.996555332967546,"request_tps":0.678005686505697,"input_tps":11108.44516770934,"output_tps":347.1389114909169,"total_tps":11455.584079200256,"mean_input_tokens":16384.0,"mean_output_tokens":512.0,"ttft_p50_ms":3553.748540522065,"ttft_p95_ms":7033.2614864571915,"ttft_p99_ms":8927.751199561753,"tpot_p50_ms":16.41629324660276,"tpot_p95_ms":22.288058708645604,"tpot_p99_ms":25.31187614718194,"e2e_p50_ms":11970.526230026735,"e2e_p95_ms":14739.94164637697,"e2e_p99_ms":17779.388954163296,"itl_p50_ms":17.28450396331027,"itl_p95_ms":619.0852579020428,"itl_p99_ms":630.4274180298671,"validation_errors":[],"timestamp":"2026-07-18T20:20:30+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":16384,"osl":512,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c8_i16384_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c8_i16384_o512_a1.log"} +{"status":"COMPLETED","completed":5,"failed":0,"duration_s":5.179662438982632,"request_tps":0.9653138711066429,"input_tps":15815.702464211237,"output_tps":494.24070200660117,"total_tps":16309.943166217838,"mean_input_tokens":16384.0,"mean_output_tokens":512.0,"ttft_p50_ms":202.5294560007751,"ttft_p95_ms":240.74701402569187,"ttft_p99_ms":248.02538682008162,"tpot_p50_ms":1.5497608591005965,"tpot_p95_ms":1.8161080821841924,"tpot_p99_ms":1.8685793291336315,"e2e_p50_ms":994.1334060276859,"e2e_p95_ms":1168.0052262032402,"e2e_p99_ms":1202.7148204436526,"itl_p50_ms":9.387932979734614,"itl_p95_ms":9.562849256326444,"itl_p99_ms":10.680640989448877,"validation_errors":[],"timestamp":"2026-07-18T20:21:20+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":16384,"osl":512,"concurrency":1,"num_prompts":5,"warmup_requests":1,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c1_i16384_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c1_i16384_o512_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":76.97803800797556,"request_tps":1.039257456674998,"input_tps":17027.194170163166,"output_tps":1064.1996356351979,"total_tps":18091.393805798365,"mean_input_tokens":16384.0,"mean_output_tokens":1024.0,"ttft_p50_ms":1237.2593369800597,"ttft_p95_ms":6755.423905301723,"ttft_p99_ms":7510.833017720139,"tpot_p50_ms":12.295709346523026,"tpot_p95_ms":23.982280935220555,"tpot_p99_ms":28.556956956642086,"e2e_p50_ms":15145.674078492448,"e2e_p95_ms":27162.059494361158,"e2e_p99_ms":35987.552555563685,"itl_p50_ms":23.85018503991887,"itl_p95_ms":599.5790489832871,"itl_p99_ms":629.716491245199,"validation_errors":[],"timestamp":"2026-07-18T20:23:18+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":16384,"osl":1024,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c16_i16384_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c16_i16384_o1024_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":18.76043252297677,"request_tps":2.132147004127445,"input_tps":34933.096515624056,"output_tps":2183.3185322265035,"total_tps":37116.415047850554,"mean_input_tokens":16384.0,"mean_output_tokens":1024.0,"ttft_p50_ms":227.4390679958742,"ttft_p95_ms":619.6131816424895,"ttft_p99_ms":635.3826031525386,"tpot_p50_ms":3.2886710860138306,"tpot_p95_ms":3.7868299464464594,"tpot_p99_ms":3.936308968306623,"e2e_p50_ms":3651.480198983336,"e2e_p95_ms":4135.786970527261,"e2e_p99_ms":4282.152071822202,"itl_p50_ms":17.228023032657802,"itl_p95_ms":19.70477967988698,"itl_p99_ms":71.99215908069164,"validation_errors":[],"timestamp":"2026-07-18T20:24:16+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":16384,"osl":1024,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c8_i16384_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c8_i16384_o1024_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":49.686521858966444,"request_tps":1.6100945891740495,"input_tps":26379.789749027626,"output_tps":3297.4737186284533,"total_tps":29677.263467656077,"mean_input_tokens":16384.0,"mean_output_tokens":2048.0,"ttft_p50_ms":235.54149497067556,"ttft_p95_ms":1041.364470438566,"ttft_p99_ms":1088.0233543989011,"tpot_p50_ms":4.387195254538985,"tpot_p95_ms":5.035412843100514,"tpot_p99_ms":5.707237617688851,"e2e_p50_ms":9240.212401520694,"e2e_p95_ms":10797.683097838308,"e2e_p99_ms":11963.669437898772,"itl_p50_ms":23.860490502556786,"itl_p95_ms":29.747055092593634,"itl_p99_ms":69.4093915366102,"validation_errors":[],"timestamp":"2026-07-18T20:25:49+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":16384,"osl":2048,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c16_i16384_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c16_i16384_o2048_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":171.02372411603574,"request_tps":0.9355427197424587,"input_tps":15327.931920260444,"output_tps":1915.9914900325555,"total_tps":17243.923410293,"mean_input_tokens":16384.0,"mean_output_tokens":2048.0,"ttft_p50_ms":1737.42485101684,"ttft_p95_ms":4938.30730994523,"ttft_p99_ms":7680.4805412550895,"tpot_p50_ms":15.224752691255917,"tpot_p95_ms":29.28440023057115,"tpot_p99_ms":31.067969917835708,"e2e_p50_ms":33543.334906979,"e2e_p95_ms":63674.580457012045,"e2e_p99_ms":67378.75526044925,"itl_p50_ms":34.11016601603478,"itl_p95_ms":607.6723189034965,"itl_p99_ms":630.2442699775565,"validation_errors":[],"timestamp":"2026-07-18T20:29:21+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":16384,"osl":2048,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":-41.89517,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c32_i16384_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c32_i16384_o2048_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":217.26571349200094,"request_tps":0.36821272309468817,"input_tps":12065.594510366742,"output_tps":47.131228556120085,"total_tps":12112.725738922862,"mean_input_tokens":32768.0,"mean_output_tokens":128.0,"ttft_p50_ms":28911.25680296682,"ttft_p95_ms":30718.88731489306,"ttft_p99_ms":39577.43630219132,"tpot_p50_ms":115.60066001179011,"tpot_p95_ms":131.75240174539968,"tpot_p99_ms":152.56236780782208,"e2e_p50_ms":43697.273848520126,"e2e_p95_ms":48030.811488279134,"e2e_p99_ms":56933.29409584402,"itl_p50_ms":648.8313874870073,"itl_p95_ms":694.8509049834684,"itl_p99_ms":713.8943988626124,"validation_errors":[],"timestamp":"2026-07-18T20:33:46+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":32768,"osl":128,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c16_i32768_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c16_i32768_o128_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":108.10885117197176,"request_tps":0.36999745688140634,"input_tps":12124.076667089923,"output_tps":47.35967448082001,"total_tps":12171.436341570743,"mean_input_tokens":32768.0,"mean_output_tokens":128.0,"ttft_p50_ms":7176.357343501877,"ttft_p95_ms":14586.2989787216,"ttft_p99_ms":18619.8861200473,"tpot_p50_ms":113.706847602606,"tpot_p95_ms":131.73432395139005,"tpot_p99_ms":134.56845112493278,"e2e_p50_ms":21887.0448290254,"e2e_p95_ms":31155.289818911115,"e2e_p99_ms":32739.610320974607,"itl_p50_ms":647.3571420065127,"itl_p95_ms":688.4339812211692,"itl_p99_ms":710.2773090807023,"validation_errors":[],"timestamp":"2026-07-18T20:36:17+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":32768,"osl":128,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c8_i32768_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c8_i32768_o128_a1.log"} +{"status":"COMPLETED","completed":5,"failed":0,"duration_s":13.23558406799566,"request_tps":0.3777695018454277,"input_tps":12378.751036470974,"output_tps":48.35449623621474,"total_tps":12427.10553270719,"mean_input_tokens":32768.0,"mean_output_tokens":128.0,"ttft_p50_ms":2960.8191199949943,"ttft_p95_ms":3010.7521782047115,"ttft_p99_ms":3015.695167647209,"tpot_p50_ms":1.3825430710777993,"tpot_p95_ms":1.8095124773241167,"tpot_p99_ms":1.8932234216481447,"e2e_p50_ms":3137.4707549693994,"e2e_p95_ms":3185.3935156250373,"e2e_p99_ms":3191.0898111527786,"itl_p50_ms":9.429798519704491,"itl_p95_ms":9.829649468883872,"itl_p99_ms":11.582384342909792,"validation_errors":[],"timestamp":"2026-07-18T20:37:16+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":32768,"osl":128,"concurrency":1,"num_prompts":5,"warmup_requests":1,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c1_i32768_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c1_i32768_o128_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":208.18878486199537,"request_tps":0.3842666167297656,"input_tps":12591.648497000959,"output_tps":98.37225388281999,"total_tps":12690.02075088378,"mean_input_tokens":32768.0,"mean_output_tokens":256.0,"ttft_p50_ms":14084.560540999519,"ttft_p95_ms":20268.4404332278,"ttft_p99_ms":29155.941551962147,"tpot_p50_ms":110.4099609273915,"tpot_p95_ms":129.18507497333098,"tpot_p99_ms":156.54536482830716,"e2e_p50_ms":42997.4313924904,"e2e_p95_ms":51347.725155236534,"e2e_p99_ms":64945.06263713168,"itl_p50_ms":648.1737510184757,"itl_p95_ms":697.022665233817,"itl_p99_ms":712.4391304864548,"validation_errors":[],"timestamp":"2026-07-18T20:41:27+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":32768,"osl":256,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c16_i32768_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c16_i32768_o256_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":110.39624956896296,"request_tps":0.362331149438302,"input_tps":11872.86710479428,"output_tps":92.75677425620532,"total_tps":11965.623879050485,"mean_input_tokens":32768.0,"mean_output_tokens":256.0,"ttft_p50_ms":9702.467896509916,"ttft_p95_ms":14571.008015351246,"ttft_p99_ms":18566.429213930383,"tpot_p50_ms":50.283154447028856,"tpot_p95_ms":75.10732316967858,"tpot_p99_ms":76.17375627562275,"e2e_p50_ms":22483.430596999824,"e2e_p95_ms":27217.169940931482,"e2e_p99_ms":29663.25021461642,"itl_p50_ms":19.16577504016459,"itl_p95_ms":680.6309910316486,"itl_p99_ms":705.6278975098394,"validation_errors":[],"timestamp":"2026-07-18T20:44:00+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":32768,"osl":256,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c8_i32768_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c8_i32768_o256_a1.log"} +{"status":"COMPLETED","completed":5,"failed":0,"duration_s":14.175552742963191,"request_tps":0.3527199320310118,"input_tps":11557.926732792195,"output_tps":90.29630259993903,"total_tps":11648.223035392135,"mean_input_tokens":32768.0,"mean_output_tokens":256.0,"ttft_p50_ms":2963.0602649995126,"ttft_p95_ms":2991.530500422232,"ttft_p99_ms":2995.557526513003,"tpot_p50_ms":1.4684309333781984,"tpot_p95_ms":1.716340143580501,"tpot_p99_ms":1.7659170703378086,"e2e_p50_ms":3337.2016490320675,"e2e_p95_ms":3364.8762474185787,"e2e_p99_ms":3369.7915999102406,"itl_p50_ms":9.426636504940689,"itl_p95_ms":9.59223534737248,"itl_p99_ms":11.282577842357568,"validation_errors":[],"timestamp":"2026-07-18T20:44:53+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":32768,"osl":256,"concurrency":1,"num_prompts":5,"warmup_requests":1,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c1_i32768_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c1_i32768_o256_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":214.64053676399635,"request_tps":0.37271617564003007,"input_tps":12213.163643372505,"output_tps":190.8306819276954,"total_tps":12403.994325300202,"mean_input_tokens":32768.0,"mean_output_tokens":512.0,"ttft_p50_ms":9089.224305498647,"ttft_p95_ms":20233.660705841605,"ttft_p99_ms":29027.48411745064,"tpot_p50_ms":65.80966365073239,"tpot_p95_ms":82.21742567091286,"tpot_p99_ms":98.62230607470066,"e2e_p50_ms":45320.603993488476,"e2e_p95_ms":58688.48046082712,"e2e_p99_ms":69587.8195534337,"itl_p50_ms":566.1431784683373,"itl_p95_ms":681.9541277596727,"itl_p99_ms":710.763073984417,"validation_errors":[],"timestamp":"2026-07-18T20:49:06+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":32768,"osl":512,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c16_i32768_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c16_i32768_o512_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":114.9099855220411,"request_tps":0.3480985557371559,"input_tps":11406.493474395125,"output_tps":178.22646053742383,"total_tps":11584.719934932547,"mean_input_tokens":32768.0,"mean_output_tokens":512.0,"ttft_p50_ms":8390.37177953287,"ttft_p95_ms":14575.124535246861,"ttft_p99_ms":18564.27873585722,"tpot_p50_ms":29.516582001012488,"tpot_p95_ms":40.196422170089015,"tpot_p99_ms":41.23432245919614,"e2e_p50_ms":23372.08154401742,"e2e_p95_ms":29816.75256890885,"e2e_p99_ms":32037.94135471224,"itl_p50_ms":17.82170351361856,"itl_p95_ms":675.6564826500835,"itl_p99_ms":694.8417060857173,"validation_errors":[],"timestamp":"2026-07-18T20:51:41+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":32768,"osl":512,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c8_i32768_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c8_i32768_o512_a1.log"} +{"status":"COMPLETED","completed":5,"failed":0,"duration_s":16.22719338600291,"request_tps":0.3081247558381137,"input_tps":10096.63199930331,"output_tps":157.75987498911422,"total_tps":10254.391874292423,"mean_input_tokens":32768.0,"mean_output_tokens":512.0,"ttft_p50_ms":2951.692725007888,"ttft_p95_ms":2980.0124745815992,"ttft_p99_ms":2983.1180308945477,"tpot_p50_ms":1.5211801056945131,"tpot_p95_ms":1.7807709906567362,"tpot_p99_ms":1.8317973480966314,"e2e_p50_ms":3731.294357974548,"e2e_p95_ms":3756.571014993824,"e2e_p99_ms":3759.5236725872383,"itl_p50_ms":9.436957014258951,"itl_p95_ms":9.617601218633352,"itl_p99_ms":11.262412857031446,"validation_errors":[],"timestamp":"2026-07-18T20:52:43+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":32768,"osl":512,"concurrency":1,"num_prompts":5,"warmup_requests":1,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c1_i32768_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c1_i32768_o512_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":225.42309948097682,"request_tps":0.35488820881353866,"input_tps":11628.976826402035,"output_tps":363.4055258250636,"total_tps":11992.382352227098,"mean_input_tokens":32768.0,"mean_output_tokens":1024.0,"ttft_p50_ms":8487.72712147911,"ttft_p95_ms":20243.07756503112,"ttft_p99_ms":29033.60715877845,"tpot_p50_ms":36.25068406839919,"tpot_p95_ms":46.65020884326529,"tpot_p99_ms":51.21381689994589,"e2e_p50_ms":46997.219121520175,"e2e_p95_ms":64053.62491296255,"e2e_p99_ms":69617.33363431583,"itl_p50_ms":24.751856981310993,"itl_p95_ms":677.9527430277085,"itl_p99_ms":701.9159695785493,"validation_errors":[],"timestamp":"2026-07-18T20:57:13+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":32768,"osl":1024,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c16_i32768_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c16_i32768_o1024_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":122.93254617700586,"request_tps":0.3253816930010181,"input_tps":10662.107316257361,"output_tps":333.19085363304254,"total_tps":10995.298169890402,"mean_input_tokens":32768.0,"mean_output_tokens":1024.0,"ttft_p50_ms":5997.255561960628,"ttft_p95_ms":14572.265929670531,"ttft_p99_ms":18572.66036372981,"tpot_p50_ms":18.254207573316258,"tpot_p95_ms":24.165887012161658,"tpot_p99_ms":29.743302017919177,"e2e_p50_ms":24947.900472965557,"e2e_p95_ms":32989.736496901605,"e2e_p99_ms":37968.55008695274,"itl_p50_ms":17.722012504236773,"itl_p95_ms":658.1360744778067,"itl_p99_ms":680.5577313690446,"validation_errors":[],"timestamp":"2026-07-18T20:59:58+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":32768,"osl":1024,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c8_i32768_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c8_i32768_o1024_a1.log"} +{"status":"COMPLETED","completed":5,"failed":0,"duration_s":20.531565635988954,"request_tps":0.24352745857995853,"input_tps":7979.907762748081,"output_tps":249.37211758587753,"total_tps":8229.27988033396,"mean_input_tokens":32768.0,"mean_output_tokens":1024.0,"ttft_p50_ms":2977.076262992341,"ttft_p95_ms":3014.943135017529,"ttft_p99_ms":3018.6965750157833,"tpot_p50_ms":1.5435006295035858,"tpot_p95_ms":1.8316803982104461,"tpot_p99_ms":1.8886257625045666,"e2e_p50_ms":4553.308925998863,"e2e_p95_ms":4593.228194199037,"e2e_p99_ms":4597.5545020378195,"itl_p50_ms":9.44138498743996,"itl_p95_ms":9.631805995013565,"itl_p99_ms":10.215156420599673,"validation_errors":[],"timestamp":"2026-07-18T21:01:04+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":32768,"osl":1024,"concurrency":1,"num_prompts":5,"warmup_requests":1,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c1_i32768_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c1_i32768_o1024_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":249.07429556600982,"request_tps":0.3211893054568465,"input_tps":10524.731161209946,"output_tps":657.7956975756216,"total_tps":11182.526858785568,"mean_input_tokens":32768.0,"mean_output_tokens":2048.0,"ttft_p50_ms":6549.6987189981155,"ttft_p95_ms":20284.124702852558,"ttft_p99_ms":29087.802990880427,"tpot_p50_ms":20.962324889364705,"tpot_p95_ms":29.641290421632178,"tpot_p99_ms":31.488760736784062,"e2e_p50_ms":50861.027585022384,"e2e_p95_ms":72425.41824062062,"e2e_p99_ms":76434.00851111971,"itl_p50_ms":24.751724471570924,"itl_p95_ms":665.6892703962512,"itl_p99_ms":684.9302939785412,"validation_errors":[],"timestamp":"2026-07-18T21:05:59+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":32768,"osl":2048,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c16_i32768_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c16_i32768_o2048_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":139.967885812046,"request_tps":0.28577983991065964,"input_tps":9364.433794192495,"output_tps":585.2771121370309,"total_tps":9949.710906329527,"mean_input_tokens":32768.0,"mean_output_tokens":2048.0,"ttft_p50_ms":4547.7245949732605,"ttft_p95_ms":14602.095228980754,"ttft_p99_ms":18586.666146675703,"tpot_p50_ms":10.86593677065029,"tpot_p95_ms":14.095971211706297,"tpot_p99_ms":18.406736284476366,"e2e_p50_ms":28315.809283492854,"e2e_p95_ms":38346.735779393915,"e2e_p99_ms":42341.37675114791,"itl_p50_ms":17.71791497594677,"itl_p95_ms":595.6992983527015,"itl_p99_ms":676.1016155267134,"validation_errors":[],"timestamp":"2026-07-18T21:09:01+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":32768,"osl":2048,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c8_i32768_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c8_i32768_o2048_a1.log"} +{"status":"COMPLETED","completed":5,"failed":0,"duration_s":28.929613493965007,"request_tps":0.1728332803700626,"input_tps":5663.400931166211,"output_tps":353.9625581978882,"total_tps":6017.363489364099,"mean_input_tokens":32768.0,"mean_output_tokens":2048.0,"ttft_p50_ms":2955.7677429984324,"ttft_p95_ms":2988.636029395275,"ttft_p99_ms":2992.674302677624,"tpot_p50_ms":1.5671430376295088,"tpot_p95_ms":1.8525311617912295,"tpot_p99_ms":1.9091158593209976,"e2e_p50_ms":6160.406544979196,"e2e_p95_ms":6181.41964658862,"e2e_p99_ms":6184.961667701136,"itl_p50_ms":9.443244023714215,"itl_p95_ms":9.628287132363766,"itl_p99_ms":9.97599384339992,"validation_errors":[],"timestamp":"2026-07-18T21:10:09+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":32768,"osl":2048,"concurrency":1,"num_prompts":5,"warmup_requests":1,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c1_i32768_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c1_i32768_o2048_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":459.97702947905054,"request_tps":0.17392172841892656,"input_tps":11398.13439366277,"output_tps":22.2619812376226,"total_tps":11420.396374900392,"mean_input_tokens":65536.0,"mean_output_tokens":128.0,"ttft_p50_ms":78432.1059040085,"ttft_p95_ms":80788.11025174509,"ttft_p99_ms":80909.01154468185,"tpot_p50_ms":125.1668815396077,"tpot_p95_ms":147.81552577830345,"tpot_p99_ms":169.5055161954146,"e2e_p50_ms":94053.2992685039,"e2e_p95_ms":98996.17796144447,"e2e_p99_ms":101686.20531550489,"itl_p50_ms":697.812583995983,"itl_p95_ms":798.7020936154295,"itl_p99_ms":841.0805165756028,"validation_errors":[],"timestamp":"2026-07-18T21:18:34+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":65536,"osl":128,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c16_i65536_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c16_i65536_o128_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":234.07212205498945,"request_tps":0.17088750103527062,"input_tps":11199.283267847495,"output_tps":21.87360013251464,"total_tps":11221.15686798001,"mean_input_tokens":65536.0,"mean_output_tokens":128.0,"ttft_p50_ms":31700.97125551547,"ttft_p95_ms":33199.941367245614,"ttft_p99_ms":40373.616831723484,"tpot_p50_ms":125.19301602357491,"tpot_p95_ms":143.1608018179343,"tpot_p99_ms":157.20718852365314,"e2e_p50_ms":47619.83880848857,"e2e_p95_ms":52223.095052456476,"e2e_p99_ms":56004.09367243409,"itl_p50_ms":695.6585579901002,"itl_p95_ms":796.6055752011016,"itl_p99_ms":835.7530290517025,"validation_errors":[],"timestamp":"2026-07-18T21:23:18+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":65536,"osl":128,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c8_i65536_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c8_i65536_o128_a1.log"} +{"status":"COMPLETED","completed":5,"failed":0,"duration_s":26.60868479096098,"request_tps":0.18790857343308112,"input_tps":12314.776268510404,"output_tps":24.052297399434384,"total_tps":12338.828565909838,"mean_input_tokens":65536.0,"mean_output_tokens":128.0,"ttft_p50_ms":6316.651745000854,"ttft_p95_ms":6378.023793362081,"ttft_p99_ms":6387.348679434508,"tpot_p50_ms":1.2009041498444504,"tpot_p95_ms":1.3861827434986596,"tpot_p99_ms":1.4205668733169245,"e2e_p50_ms":6461.149255046621,"e2e_p95_ms":6530.229869589675,"e2e_p99_ms":6539.801756304223,"itl_p50_ms":9.679983020760119,"itl_p95_ms":12.553182418923827,"itl_p99_ms":13.373790894402193,"validation_errors":[],"timestamp":"2026-07-18T21:24:28+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":65536,"osl":128,"concurrency":1,"num_prompts":5,"warmup_requests":1,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c1_i65536_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c1_i65536_o128_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":450.39426645002095,"request_tps":0.17762215454151964,"input_tps":11640.645520033031,"output_tps":45.47127156262903,"total_tps":11686.116791595661,"mean_input_tokens":65536.0,"mean_output_tokens":256.0,"ttft_p50_ms":62135.535865993006,"ttft_p95_ms":66081.88818896888,"ttft_p99_ms":67129.17027874035,"tpot_p50_ms":123.00653767842782,"tpot_p95_ms":144.88961453381788,"tpot_p99_ms":154.18319848333664,"e2e_p50_ms":93661.12045798218,"e2e_p95_ms":101519.33462232992,"e2e_p99_ms":104163.29168940311,"itl_p50_ms":699.8937040043529,"itl_p95_ms":796.6677608637838,"itl_p99_ms":834.3760684865993,"validation_errors":[],"timestamp":"2026-07-18T21:32:42+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":65536,"osl":256,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c16_i65536_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c16_i65536_o256_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":235.31995585997356,"request_tps":0.16998133394093393,"input_tps":11139.896701153046,"output_tps":43.515221488879085,"total_tps":11183.411922641926,"mean_input_tokens":65536.0,"mean_output_tokens":256.0,"ttft_p50_ms":16708.38721349719,"ttft_p95_ms":30978.198071787465,"ttft_p99_ms":40416.17535323545,"tpot_p50_ms":120.74719167647737,"tpot_p95_ms":144.7834317764386,"tpot_p99_ms":146.48951114694515,"e2e_p50_ms":47748.23815500713,"e2e_p95_ms":64327.80338411975,"e2e_p99_ms":70553.13558641064,"itl_p50_ms":694.1700390307233,"itl_p95_ms":797.6084398804232,"itl_p99_ms":857.3809229501057,"validation_errors":[],"timestamp":"2026-07-18T21:37:20+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":65536,"osl":256,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c8_i65536_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c8_i65536_o256_a1.log"} +{"status":"COMPLETED","completed":5,"failed":0,"duration_s":27.693305738968775,"request_tps":0.18054904846423678,"input_tps":11832.462440152221,"output_tps":46.220556406844615,"total_tps":11878.682996559066,"mean_input_tokens":65536.0,"mean_output_tokens":256.0,"ttft_p50_ms":6322.25893100258,"ttft_p95_ms":6373.712160240393,"ttft_p99_ms":6382.293663283344,"tpot_p50_ms":1.3912588157051917,"tpot_p95_ms":1.6173196031584165,"tpot_p99_ms":1.6589061449665357,"e2e_p50_ms":6677.029929007404,"e2e_p95_ms":6727.522982016671,"e2e_p99_ms":6736.606911609415,"itl_p50_ms":9.670989500591531,"itl_p95_ms":10.020750720286742,"itl_p99_ms":12.875750899547713,"validation_errors":[],"timestamp":"2026-07-18T21:38:33+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":65536,"osl":256,"concurrency":1,"num_prompts":5,"warmup_requests":1,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c1_i65536_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c1_i65536_o256_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":453.996303818014,"request_tps":0.17621288835881863,"input_tps":11548.287851483537,"output_tps":90.22099883971514,"total_tps":11638.508850323253,"mean_input_tokens":65536.0,"mean_output_tokens":512.0,"ttft_p50_ms":30171.640759013826,"ttft_p95_ms":43792.00704125394,"ttft_p99_ms":63088.14689005721,"tpot_p50_ms":118.76432454994234,"tpot_p95_ms":143.9796117512799,"tpot_p99_ms":163.50604933187145,"e2e_p50_ms":93678.21157348226,"e2e_p95_ms":116407.53947108457,"e2e_p99_ms":136768.98591509846,"itl_p50_ms":697.6034439867362,"itl_p95_ms":797.0853464328683,"itl_p99_ms":843.7164889508858,"validation_errors":[],"timestamp":"2026-07-18T21:46:50+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":65536,"osl":512,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c16_i65536_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c16_i65536_o512_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":240.23397363704862,"request_tps":0.16650434322180002,"input_tps":10912.028637383886,"output_tps":85.25022372956161,"total_tps":10997.278861113447,"mean_input_tokens":65536.0,"mean_output_tokens":512.0,"ttft_p50_ms":16580.104249500437,"ttft_p95_ms":30959.689756046264,"ttft_p99_ms":40336.059981213184,"tpot_p50_ms":61.893560782787084,"tpot_p95_ms":83.43671823682267,"tpot_p99_ms":83.57458911187092,"e2e_p50_ms":48884.4735425082,"e2e_p95_ms":63618.254215450725,"e2e_p99_ms":66684.1153533553,"itl_p50_ms":23.71838700491935,"itl_p95_ms":789.8835640371544,"itl_p99_ms":804.7707959770922,"validation_errors":[],"timestamp":"2026-07-18T21:51:33+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":65536,"osl":512,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c8_i65536_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c8_i65536_o512_a1.log"} +{"status":"COMPLETED","completed":5,"failed":0,"duration_s":29.82099165598629,"request_tps":0.16766712715927728,"input_tps":10988.232845510396,"output_tps":85.84556910554997,"total_tps":11074.078414615946,"mean_input_tokens":65536.0,"mean_output_tokens":512.0,"ttft_p50_ms":6293.814654985908,"ttft_p95_ms":6358.3394928020425,"ttft_p99_ms":6363.198921757285,"tpot_p50_ms":1.5159355146845042,"tpot_p95_ms":1.8277595021740083,"tpot_p99_ms":1.8893790519304225,"e2e_p50_ms":7068.45770298969,"e2e_p95_ms":7127.025614597369,"e2e_p99_ms":7132.825826921035,"itl_p50_ms":9.685177967185155,"itl_p95_ms":9.881039426545613,"itl_p99_ms":13.061296222149393,"validation_errors":[],"timestamp":"2026-07-18T21:52:53+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":65536,"osl":512,"concurrency":1,"num_prompts":5,"warmup_requests":1,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c1_i65536_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c1_i65536_o512_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":466.0357544760336,"request_tps":0.17166064884859406,"input_tps":11249.95228294146,"output_tps":175.7805044209603,"total_tps":11425.73278736242,"mean_input_tokens":65536.0,"mean_output_tokens":1024.0,"ttft_p50_ms":17069.568242994137,"ttft_p95_ms":43767.12617217852,"ttft_p99_ms":63026.48430861878,"tpot_p50_ms":74.29160604592303,"tpot_p95_ms":91.15834723500751,"tpot_p99_ms":96.01304768383301,"e2e_p50_ms":96931.14117198274,"e2e_p95_ms":132216.23605113127,"e2e_p99_ms":144600.28680766516,"itl_p50_ms":557.7469629934058,"itl_p95_ms":792.1489162254147,"itl_p99_ms":817.5934754265472,"validation_errors":[],"timestamp":"2026-07-18T22:01:25+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":65536,"osl":1024,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c16_i65536_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c16_i65536_o1024_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":249.5686882029986,"request_tps":0.16027651660958403,"input_tps":10503.881792525699,"output_tps":164.12315300821405,"total_tps":10668.004945533912,"mean_input_tokens":65536.0,"mean_output_tokens":1024.0,"ttft_p50_ms":14285.055401502177,"ttft_p95_ms":31017.82778989289,"ttft_p99_ms":40353.96495280671,"tpot_p50_ms":36.953045451144874,"tpot_p95_ms":43.897369301605146,"tpot_p99_ms":47.40239440787466,"e2e_p50_ms":50881.05798047036,"e2e_p95_ms":66331.4846790541,"e2e_p99_ms":73095.72803126764,"itl_p50_ms":18.82347700302489,"itl_p95_ms":770.8452847437002,"itl_p99_ms":794.9775614991086,"validation_errors":[],"timestamp":"2026-07-18T22:06:21+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":65536,"osl":1024,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c8_i65536_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c8_i65536_o1024_a1.log"} +{"status":"COMPLETED","completed":5,"failed":0,"duration_s":34.32074699102668,"request_tps":0.14568447479617133,"input_tps":9547.577740241884,"output_tps":149.18090219127944,"total_tps":9696.758642433164,"mean_input_tokens":65536.0,"mean_output_tokens":1024.0,"ttft_p50_ms":6375.553043966647,"ttft_p95_ms":6409.251518570818,"ttft_p99_ms":6415.734740491025,"tpot_p50_ms":1.5573445171002165,"tpot_p95_ms":1.8320466486535936,"tpot_p99_ms":1.880340835478754,"e2e_p50_ms":7958.852722949814,"e2e_p95_ms":8002.409728965722,"e2e_p99_ms":8008.897135364823,"itl_p50_ms":9.693388012237847,"itl_p95_ms":9.866890765260905,"itl_p99_ms":11.323690977878876,"validation_errors":[],"timestamp":"2026-07-18T22:07:40+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":65536,"osl":1024,"concurrency":1,"num_prompts":5,"warmup_requests":1,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c1_i65536_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c1_i65536_o1024_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":1074.488647656981,"request_tps":0.07445402068644205,"input_tps":9758.837399413333,"output_tps":9.530114647864583,"total_tps":9768.367514061198,"mean_input_tokens":131072.0,"mean_output_tokens":128.0,"ttft_p50_ms":202491.09972349834,"ttft_p95_ms":206337.07478391007,"ttft_p99_ms":206846.70807102404,"tpot_p50_ms":145.6569577913317,"tpot_p95_ms":173.23047976356958,"tpot_p99_ms":184.32163134556419,"e2e_p50_ms":220702.6488840056,"e2e_p95_ms":227232.97784725437,"e2e_p99_ms":228668.44236867095,"itl_p50_ms":773.5487699974328,"itl_p95_ms":1016.6898223920726,"itl_p99_ms":1038.38686123956,"validation_errors":[],"timestamp":"2026-07-18T22:26:28+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":131072,"osl":128,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c16_i131072_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c16_i131072_o128_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":545.6171755020041,"request_tps":0.0733114751440831,"input_tps":9609.08167008526,"output_tps":9.383868818442636,"total_tps":9618.465538903703,"mean_input_tokens":131072.0,"mean_output_tokens":128.0,"ttft_p50_ms":92557.45471947012,"ttft_p95_ms":95280.72428232699,"ttft_p99_ms":107018.79048773204,"tpot_p50_ms":149.7355252204144,"tpot_p95_ms":174.6690899915819,"tpot_p99_ms":178.468197617381,"e2e_p50_ms":111189.87346452195,"e2e_p95_ms":117168.7853934418,"e2e_p99_ms":124867.80478070083,"itl_p50_ms":764.5383169874549,"itl_p95_ms":1018.7470455130097,"itl_p99_ms":1034.5638845174108,"validation_errors":[],"timestamp":"2026-07-18T22:36:32+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":131072,"osl":128,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c8_i131072_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c8_i131072_o128_a1.log"} +{"status":"COMPLETED","completed":5,"failed":0,"duration_s":59.75026716798311,"request_tps":0.08368163419157439,"input_tps":10968.319156758038,"output_tps":10.711249176521521,"total_tps":10979.03040593456,"mean_input_tokens":131072.0,"mean_output_tokens":128.0,"ttft_p50_ms":14516.49394701235,"ttft_p95_ms":14667.706190794706,"ttft_p99_ms":14686.722060563043,"tpot_p50_ms":0.9185049373942508,"tpot_p95_ms":1.3975718911135875,"tpot_p99_ms":1.4927319276300586,"e2e_p50_ms":14633.32717801677,"e2e_p95_ms":14784.323240199592,"e2e_p99_ms":14803.332494439092,"itl_p50_ms":9.919718984747306,"itl_p95_ms":15.016702606226318,"itl_p99_ms":16.6832009307109,"validation_errors":[],"timestamp":"2026-07-18T22:38:28+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":131072,"osl":128,"concurrency":1,"num_prompts":5,"warmup_requests":1,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/raw_outputs/vllm_adaptive_c1_i131072_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/tp8_dp1/logs/vllm_c1_i131072_o128_a1.log"} diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/adaptive_shapes.jsonl b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/adaptive_shapes.jsonl new file mode 100644 index 0000000..c274c3e --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/adaptive_shapes.jsonl @@ -0,0 +1,99 @@ +{"timestamp":"2026-07-18T05:29:14+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":128,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_BACKOFF_FOUND","tested_points":3,"search_cap":512,"max_successful_concurrency":1,"saturation_concurrency":null,"stop_probe_concurrency":1,"best_tps_concurrency":16,"best_total_tps":3015.0735320176436,"last_total_tps":2174.9382852560016} +{"timestamp":"2026-07-18T05:54:34+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":256,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":16,"search_cap":512,"max_successful_concurrency":256,"saturation_concurrency":null,"stop_probe_concurrency":256,"best_tps_concurrency":240,"best_total_tps":22823.756401450846,"last_total_tps":22274.270946602188} +{"timestamp":"2026-07-18T06:18:21+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":512,"status":"COMPLETED","stop_reason":"TPS_PLATEAU","tested_points":13,"search_cap":512,"max_successful_concurrency":208,"saturation_concurrency":192,"stop_probe_concurrency":208,"best_tps_concurrency":208,"best_total_tps":16879.23780084254,"last_total_tps":16879.23780084254} +{"timestamp":"2026-07-18T06:42:43+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":1024,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":10,"search_cap":512,"max_successful_concurrency":160,"saturation_concurrency":null,"stop_probe_concurrency":160,"best_tps_concurrency":160,"best_total_tps":12567.806372858291,"last_total_tps":12567.806372858291} +{"timestamp":"2026-07-18T07:15:50+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":2048,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":9,"search_cap":512,"max_successful_concurrency":144,"saturation_concurrency":null,"stop_probe_concurrency":144,"best_tps_concurrency":144,"best_total_tps":10264.679524612942,"last_total_tps":10264.679524612942} +{"timestamp":"2026-07-18T08:12:08+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":4096,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":9,"search_cap":512,"max_successful_concurrency":144,"saturation_concurrency":null,"stop_probe_concurrency":144,"best_tps_concurrency":144,"best_total_tps":9644.270634946442,"last_total_tps":9644.270634946442} +{"timestamp":"2026-07-18T08:16:06+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":128,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":3,"search_cap":512,"max_successful_concurrency":48,"saturation_concurrency":null,"stop_probe_concurrency":48,"best_tps_concurrency":48,"best_total_tps":22990.788025418202,"last_total_tps":22990.788025418202} +{"timestamp":"2026-07-18T08:23:51+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":256,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":5,"search_cap":512,"max_successful_concurrency":80,"saturation_concurrency":null,"stop_probe_concurrency":80,"best_tps_concurrency":80,"best_total_tps":26475.222191175653,"last_total_tps":26475.222191175653} +{"timestamp":"2026-07-18T08:34:29+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":512,"status":"COMPLETED","stop_reason":"TPS_PLATEAU","tested_points":6,"search_cap":512,"max_successful_concurrency":96,"saturation_concurrency":80,"stop_probe_concurrency":96,"best_tps_concurrency":80,"best_total_tps":24080.131736565483,"last_total_tps":22767.404745722128} +{"timestamp":"2026-07-18T08:48:55+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":1024,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":6,"search_cap":512,"max_successful_concurrency":96,"saturation_concurrency":null,"stop_probe_concurrency":96,"best_tps_concurrency":80,"best_total_tps":17812.993295797234,"last_total_tps":15577.812364742018} +{"timestamp":"2026-07-18T09:02:14+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":2048,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":4,"search_cap":512,"max_successful_concurrency":64,"saturation_concurrency":null,"stop_probe_concurrency":64,"best_tps_concurrency":64,"best_total_tps":11211.68138000053,"last_total_tps":11211.68138000053} +{"timestamp":"2026-07-18T09:23:47+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":4096,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":4,"search_cap":512,"max_successful_concurrency":64,"saturation_concurrency":null,"stop_probe_concurrency":64,"best_tps_concurrency":64,"best_total_tps":8406.252728727331,"last_total_tps":8406.252728727331} +{"timestamp":"2026-07-18T09:25:57+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":8192,"osl":128,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_BACKOFF_FOUND","tested_points":2,"search_cap":512,"max_successful_concurrency":8,"saturation_concurrency":null,"stop_probe_concurrency":8,"best_tps_concurrency":16,"best_total_tps":22475.134272625077,"last_total_tps":17103.958134486435} +{"timestamp":"2026-07-18T09:28:57+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":8192,"osl":256,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":2,"search_cap":512,"max_successful_concurrency":32,"saturation_concurrency":null,"stop_probe_concurrency":32,"best_tps_concurrency":32,"best_total_tps":22539.211705624853,"last_total_tps":22539.211705624853} +{"timestamp":"2026-07-18T09:34:58+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":8192,"osl":512,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":3,"search_cap":512,"max_successful_concurrency":48,"saturation_concurrency":null,"stop_probe_concurrency":48,"best_tps_concurrency":48,"best_total_tps":18690.72143294463,"last_total_tps":18690.72143294463} +{"timestamp":"2026-07-18T09:45:26+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":8192,"osl":1024,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":4,"search_cap":512,"max_successful_concurrency":64,"saturation_concurrency":null,"stop_probe_concurrency":64,"best_tps_concurrency":32,"best_total_tps":17720.008987633595,"last_total_tps":17096.31387964654} +{"timestamp":"2026-07-18T09:52:23+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":8192,"osl":2048,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":2,"search_cap":512,"max_successful_concurrency":32,"saturation_concurrency":null,"stop_probe_concurrency":32,"best_tps_concurrency":32,"best_total_tps":9893.374561568064,"last_total_tps":9893.374561568064} +{"timestamp":"2026-07-18T10:10:27+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":8192,"osl":4096,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":3,"search_cap":512,"max_successful_concurrency":48,"saturation_concurrency":null,"stop_probe_concurrency":48,"best_tps_concurrency":32,"best_total_tps":7752.108917909322,"last_total_tps":7707.917754293005} +{"timestamp":"2026-07-18T10:14:08+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":16384,"osl":128,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_BACKOFF_FOUND","tested_points":3,"search_cap":512,"max_successful_concurrency":1,"saturation_concurrency":null,"stop_probe_concurrency":1,"best_tps_concurrency":8,"best_total_tps":24865.616658934323,"last_total_tps":11122.032460750675} +{"timestamp":"2026-07-18T10:17:49+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":16384,"osl":256,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_BACKOFF_FOUND","tested_points":3,"search_cap":512,"max_successful_concurrency":1,"saturation_concurrency":null,"stop_probe_concurrency":1,"best_tps_concurrency":16,"best_total_tps":23012.01710741807,"last_total_tps":15887.249318921436} +{"timestamp":"2026-07-18T10:21:02+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":16384,"osl":512,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_BACKOFF_FOUND","tested_points":2,"search_cap":512,"max_successful_concurrency":8,"saturation_concurrency":null,"stop_probe_concurrency":8,"best_tps_concurrency":16,"best_total_tps":19442.486909391213,"last_total_tps":18631.350055538867} +{"timestamp":"2026-07-18T10:26:36+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":16384,"osl":1024,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":2,"search_cap":512,"max_successful_concurrency":32,"saturation_concurrency":null,"stop_probe_concurrency":32,"best_tps_concurrency":16,"best_total_tps":17326.656171496328,"last_total_tps":16664.646127980955} +{"timestamp":"2026-07-18T10:33:30+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":16384,"osl":2048,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":2,"search_cap":512,"max_successful_concurrency":32,"saturation_concurrency":null,"stop_probe_concurrency":32,"best_tps_concurrency":16,"best_total_tps":13951.617144820304,"last_total_tps":13577.5608045342} +{"timestamp":"2026-07-18T10:38:51+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":32768,"osl":128,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_BACKOFF_FOUND","tested_points":3,"search_cap":512,"max_successful_concurrency":1,"saturation_concurrency":null,"stop_probe_concurrency":1,"best_tps_concurrency":16,"best_total_tps":24027.01351446888,"last_total_tps":10012.090128383596} +{"timestamp":"2026-07-18T10:43:53+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":32768,"osl":256,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_BACKOFF_FOUND","tested_points":3,"search_cap":512,"max_successful_concurrency":1,"saturation_concurrency":null,"stop_probe_concurrency":1,"best_tps_concurrency":8,"best_total_tps":31754.471763504465,"last_total_tps":14216.435608892436} +{"timestamp":"2026-07-18T10:49:00+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":32768,"osl":512,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_BACKOFF_FOUND","tested_points":3,"search_cap":512,"max_successful_concurrency":1,"saturation_concurrency":null,"stop_probe_concurrency":1,"best_tps_concurrency":16,"best_total_tps":21601.934455438146,"last_total_tps":20658.797131822408} +{"timestamp":"2026-07-18T10:55:38+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":32768,"osl":1024,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_BACKOFF_FOUND","tested_points":3,"search_cap":512,"max_successful_concurrency":1,"saturation_concurrency":null,"stop_probe_concurrency":1,"best_tps_concurrency":8,"best_total_tps":16002.913115323085,"last_total_tps":8422.91731241034} +{"timestamp":"2026-07-18T11:04:00+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":32768,"osl":2048,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_BACKOFF_FOUND","tested_points":3,"search_cap":512,"max_successful_concurrency":1,"saturation_concurrency":null,"stop_probe_concurrency":1,"best_tps_concurrency":8,"best_total_tps":13118.917606193083,"last_total_tps":4303.257993236072} +{"timestamp":"2026-07-18T11:13:43+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":65536,"osl":128,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":3,"search_cap":512,"max_successful_concurrency":1,"saturation_concurrency":null,"stop_probe_concurrency":1,"best_tps_concurrency":16,"best_total_tps":22082.39716918432,"last_total_tps":12976.971644142252} +{"timestamp":"2026-07-18T11:23:26+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":65536,"osl":256,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":3,"search_cap":512,"max_successful_concurrency":1,"saturation_concurrency":null,"stop_probe_concurrency":1,"best_tps_concurrency":16,"best_total_tps":21391.62354069105,"last_total_tps":9648.08002379338} +{"timestamp":"2026-07-18T11:34:07+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":65536,"osl":512,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":3,"search_cap":512,"max_successful_concurrency":1,"saturation_concurrency":null,"stop_probe_concurrency":1,"best_tps_concurrency":16,"best_total_tps":18380.036907849004,"last_total_tps":8694.767469837296} +{"timestamp":"2026-07-18T11:46:01+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":65536,"osl":1024,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":3,"search_cap":512,"max_successful_concurrency":1,"saturation_concurrency":null,"stop_probe_concurrency":1,"best_tps_concurrency":16,"best_total_tps":15690.052427755394,"last_total_tps":11290.434955219338} +{"timestamp":"2026-07-18T12:05:17+00:00","engine":"vllm","tp":2,"dp":4,"mark":"Y","isl":131072,"osl":128,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_GROUP_SKIP_THRESHOLD","tested_points":3,"search_cap":512,"max_successful_concurrency":1,"saturation_concurrency":null,"stop_probe_concurrency":1,"best_tps_concurrency":16,"best_total_tps":19183.73328417493,"last_total_tps":7492.046543774283} +{"timestamp":"2026-07-18T12:20:35+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":128,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_BACKOFF_FOUND","tested_points":3,"search_cap":512,"max_successful_concurrency":1,"saturation_concurrency":null,"stop_probe_concurrency":1,"best_tps_concurrency":16,"best_total_tps":3344.8590600064417,"last_total_tps":3105.1557066813575} +{"timestamp":"2026-07-18T12:22:56+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":256,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":2,"search_cap":512,"max_successful_concurrency":32,"saturation_concurrency":null,"stop_probe_concurrency":32,"best_tps_concurrency":32,"best_total_tps":6548.10995313187,"last_total_tps":6548.10995313187} +{"timestamp":"2026-07-18T12:25:15+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":512,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_BACKOFF_FOUND","tested_points":2,"search_cap":512,"max_successful_concurrency":8,"saturation_concurrency":null,"stop_probe_concurrency":8,"best_tps_concurrency":16,"best_total_tps":3752.4892505307353,"last_total_tps":2351.8356531240383} +{"timestamp":"2026-07-18T12:30:27+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":1024,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":3,"search_cap":512,"max_successful_concurrency":48,"saturation_concurrency":null,"stop_probe_concurrency":48,"best_tps_concurrency":48,"best_total_tps":6282.932443000561,"last_total_tps":6282.932443000561} +{"timestamp":"2026-07-18T13:00:40+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":2048,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":9,"search_cap":512,"max_successful_concurrency":144,"saturation_concurrency":null,"stop_probe_concurrency":144,"best_tps_concurrency":144,"best_total_tps":10013.653613623694,"last_total_tps":10013.653613623694} +{"timestamp":"2026-07-18T13:37:21+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":4096,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":7,"search_cap":512,"max_successful_concurrency":112,"saturation_concurrency":null,"stop_probe_concurrency":112,"best_tps_concurrency":112,"best_total_tps":8005.974972196393,"last_total_tps":8005.974972196393} +{"timestamp":"2026-07-18T13:39:39+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":128,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":2,"search_cap":512,"max_successful_concurrency":32,"saturation_concurrency":null,"stop_probe_concurrency":32,"best_tps_concurrency":32,"best_total_tps":19178.900984274085,"last_total_tps":19178.900984274085} +{"timestamp":"2026-07-18T13:44:54+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":256,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":4,"search_cap":512,"max_successful_concurrency":64,"saturation_concurrency":null,"stop_probe_concurrency":64,"best_tps_concurrency":64,"best_total_tps":24635.58080407481,"last_total_tps":24635.58080407481} +{"timestamp":"2026-07-18T13:56:47+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":512,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":7,"search_cap":512,"max_successful_concurrency":112,"saturation_concurrency":null,"stop_probe_concurrency":112,"best_tps_concurrency":48,"best_total_tps":27810.19370932178,"last_total_tps":25413.33859287685} +{"timestamp":"2026-07-18T14:07:21+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":1024,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":5,"search_cap":512,"max_successful_concurrency":80,"saturation_concurrency":null,"stop_probe_concurrency":80,"best_tps_concurrency":80,"best_total_tps":17567.35396640895,"last_total_tps":17567.35396640895} +{"timestamp":"2026-07-18T14:23:11+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":2048,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":5,"search_cap":512,"max_successful_concurrency":80,"saturation_concurrency":null,"stop_probe_concurrency":80,"best_tps_concurrency":64,"best_total_tps":12739.402829165518,"last_total_tps":12095.484089529828} +{"timestamp":"2026-07-18T14:33:27+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":4096,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":2,"search_cap":512,"max_successful_concurrency":32,"saturation_concurrency":null,"stop_probe_concurrency":32,"best_tps_concurrency":32,"best_total_tps":4580.400381472649,"last_total_tps":4580.400381472649} +{"timestamp":"2026-07-18T14:35:41+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":8192,"osl":128,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":2,"search_cap":512,"max_successful_concurrency":32,"saturation_concurrency":null,"stop_probe_concurrency":32,"best_tps_concurrency":32,"best_total_tps":39853.46551460155,"last_total_tps":39853.46551460155} +{"timestamp":"2026-07-18T14:39:41+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":8192,"osl":256,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":3,"search_cap":512,"max_successful_concurrency":48,"saturation_concurrency":null,"stop_probe_concurrency":48,"best_tps_concurrency":32,"best_total_tps":42569.34108492768,"last_total_tps":31967.098642717658} +{"timestamp":"2026-07-18T14:46:04+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":8192,"osl":512,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":4,"search_cap":512,"max_successful_concurrency":64,"saturation_concurrency":null,"stop_probe_concurrency":64,"best_tps_concurrency":48,"best_total_tps":39561.92047849611,"last_total_tps":28912.961345619125} +{"timestamp":"2026-07-18T14:49:49+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":8192,"osl":1024,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":2,"search_cap":512,"max_successful_concurrency":32,"saturation_concurrency":null,"stop_probe_concurrency":32,"best_tps_concurrency":32,"best_total_tps":19481.210961119526,"last_total_tps":19481.210961119526} +{"timestamp":"2026-07-18T15:02:28+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":8192,"osl":2048,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":4,"search_cap":512,"max_successful_concurrency":64,"saturation_concurrency":null,"stop_probe_concurrency":64,"best_tps_concurrency":48,"best_total_tps":14382.678920590475,"last_total_tps":14183.722585941723} +{"timestamp":"2026-07-18T15:10:11+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":8192,"osl":4096,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_BACKOFF_FOUND","tested_points":2,"search_cap":512,"max_successful_concurrency":8,"saturation_concurrency":null,"stop_probe_concurrency":8,"best_tps_concurrency":16,"best_total_tps":6412.76920954965,"last_total_tps":2138.181531776794} +{"timestamp":"2026-07-18T15:13:40+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":16384,"osl":128,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_BACKOFF_FOUND","tested_points":3,"search_cap":512,"max_successful_concurrency":1,"saturation_concurrency":null,"stop_probe_concurrency":1,"best_tps_concurrency":1,"best_total_tps":33408.61928165981,"last_total_tps":33408.61928165981} +{"timestamp":"2026-07-18T15:15:44+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":16384,"osl":256,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_BACKOFF_FOUND","tested_points":2,"search_cap":512,"max_successful_concurrency":8,"saturation_concurrency":null,"stop_probe_concurrency":8,"best_tps_concurrency":8,"best_total_tps":50503.577165846604,"last_total_tps":50503.577165846604} +{"timestamp":"2026-07-18T15:18:23+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":16384,"osl":512,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_BACKOFF_FOUND","tested_points":2,"search_cap":512,"max_successful_concurrency":8,"saturation_concurrency":null,"stop_probe_concurrency":8,"best_tps_concurrency":16,"best_total_tps":30999.559317019954,"last_total_tps":26123.82918959831} +{"timestamp":"2026-07-18T15:22:44+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":16384,"osl":1024,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":2,"search_cap":512,"max_successful_concurrency":32,"saturation_concurrency":null,"stop_probe_concurrency":32,"best_tps_concurrency":16,"best_total_tps":32508.7078149849,"last_total_tps":20577.25215102256} +{"timestamp":"2026-07-18T15:30:35+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":16384,"osl":2048,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":2,"search_cap":512,"max_successful_concurrency":32,"saturation_concurrency":null,"stop_probe_concurrency":32,"best_tps_concurrency":32,"best_total_tps":11633.976050505793,"last_total_tps":11633.976050505793} +{"timestamp":"2026-07-18T15:36:59+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":32768,"osl":128,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_BACKOFF_FOUND","tested_points":3,"search_cap":512,"max_successful_concurrency":1,"saturation_concurrency":null,"stop_probe_concurrency":1,"best_tps_concurrency":1,"best_total_tps":27287.043986532444,"last_total_tps":27287.043986532444} +{"timestamp":"2026-07-18T15:43:07+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":32768,"osl":256,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_BACKOFF_FOUND","tested_points":3,"search_cap":512,"max_successful_concurrency":1,"saturation_concurrency":null,"stop_probe_concurrency":1,"best_tps_concurrency":1,"best_total_tps":23358.28664193622,"last_total_tps":23358.28664193622} +{"timestamp":"2026-07-18T15:49:39+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":32768,"osl":512,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_BACKOFF_FOUND","tested_points":3,"search_cap":512,"max_successful_concurrency":1,"saturation_concurrency":null,"stop_probe_concurrency":1,"best_tps_concurrency":16,"best_total_tps":18569.10902612545,"last_total_tps":9111.296968823292} +{"timestamp":"2026-07-18T15:57:12+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":32768,"osl":1024,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_BACKOFF_FOUND","tested_points":3,"search_cap":512,"max_successful_concurrency":1,"saturation_concurrency":null,"stop_probe_concurrency":1,"best_tps_concurrency":16,"best_total_tps":14748.417896491363,"last_total_tps":9673.325803607086} +{"timestamp":"2026-07-18T16:05:47+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":32768,"osl":2048,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_BACKOFF_FOUND","tested_points":3,"search_cap":512,"max_successful_concurrency":1,"saturation_concurrency":null,"stop_probe_concurrency":1,"best_tps_concurrency":16,"best_total_tps":15083.518350142393,"last_total_tps":6269.492442147328} +{"timestamp":"2026-07-18T16:16:34+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":65536,"osl":128,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":3,"search_cap":512,"max_successful_concurrency":1,"saturation_concurrency":null,"stop_probe_concurrency":1,"best_tps_concurrency":16,"best_total_tps":18097.595470378677,"last_total_tps":9234.20143323196} +{"timestamp":"2026-07-18T16:27:52+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":65536,"osl":256,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":3,"search_cap":512,"max_successful_concurrency":1,"saturation_concurrency":null,"stop_probe_concurrency":1,"best_tps_concurrency":16,"best_total_tps":16346.160186620771,"last_total_tps":8944.957286178149} +{"timestamp":"2026-07-18T16:40:02+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":65536,"osl":512,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":3,"search_cap":512,"max_successful_concurrency":1,"saturation_concurrency":null,"stop_probe_concurrency":1,"best_tps_concurrency":16,"best_total_tps":14751.439899006828,"last_total_tps":8379.130790916777} +{"timestamp":"2026-07-18T16:53:14+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":65536,"osl":1024,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":3,"search_cap":512,"max_successful_concurrency":1,"saturation_concurrency":null,"stop_probe_concurrency":1,"best_tps_concurrency":16,"best_total_tps":14436.120234197522,"last_total_tps":7485.43284228809} +{"timestamp":"2026-07-18T17:15:45+00:00","engine":"vllm","tp":4,"dp":2,"mark":"Y","isl":131072,"osl":128,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_GROUP_SKIP_THRESHOLD","tested_points":3,"search_cap":512,"max_successful_concurrency":1,"saturation_concurrency":null,"stop_probe_concurrency":1,"best_tps_concurrency":8,"best_total_tps":14275.478163292184,"last_total_tps":8262.033751699666} +{"timestamp":"2026-07-18T17:30:21+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":128,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_BACKOFF_FOUND","tested_points":2,"search_cap":512,"max_successful_concurrency":8,"saturation_concurrency":null,"stop_probe_concurrency":8,"best_tps_concurrency":8,"best_total_tps":10025.042822339861,"last_total_tps":10025.042822339861} +{"timestamp":"2026-07-18T17:37:20+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":256,"status":"COMPLETED","stop_reason":"TPS_PLATEAU","tested_points":6,"search_cap":512,"max_successful_concurrency":96,"saturation_concurrency":80,"stop_probe_concurrency":96,"best_tps_concurrency":64,"best_total_tps":15042.006973739983,"last_total_tps":13845.874509801075} +{"timestamp":"2026-07-18T17:47:07+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":512,"status":"COMPLETED","stop_reason":"TPS_PLATEAU","tested_points":7,"search_cap":512,"max_successful_concurrency":112,"saturation_concurrency":96,"stop_probe_concurrency":112,"best_tps_concurrency":80,"best_total_tps":14896.170124755301,"last_total_tps":10795.07855914963} +{"timestamp":"2026-07-18T18:06:38+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":1024,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":9,"search_cap":512,"max_successful_concurrency":144,"saturation_concurrency":null,"stop_probe_concurrency":144,"best_tps_concurrency":80,"best_total_tps":10780.359050625337,"last_total_tps":9446.638839430734} +{"timestamp":"2026-07-18T18:27:39+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":2048,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":7,"search_cap":512,"max_successful_concurrency":112,"saturation_concurrency":null,"stop_probe_concurrency":112,"best_tps_concurrency":80,"best_total_tps":9194.780039334513,"last_total_tps":6468.653255749296} +{"timestamp":"2026-07-18T18:46:10+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":4096,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":5,"search_cap":512,"max_successful_concurrency":80,"saturation_concurrency":null,"stop_probe_concurrency":80,"best_tps_concurrency":80,"best_total_tps":7765.878131868169,"last_total_tps":7765.878131868169} +{"timestamp":"2026-07-18T18:48:27+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":4096,"osl":128,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":2,"search_cap":512,"max_successful_concurrency":32,"saturation_concurrency":null,"stop_probe_concurrency":32,"best_tps_concurrency":32,"best_total_tps":21699.142108086646,"last_total_tps":21699.142108086646} +{"timestamp":"2026-07-18T18:51:36+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":4096,"osl":256,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":3,"search_cap":512,"max_successful_concurrency":48,"saturation_concurrency":null,"stop_probe_concurrency":48,"best_tps_concurrency":32,"best_total_tps":49644.3174513865,"last_total_tps":26136.671923171692} +{"timestamp":"2026-07-18T18:56:21+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":4096,"osl":512,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":4,"search_cap":512,"max_successful_concurrency":64,"saturation_concurrency":null,"stop_probe_concurrency":64,"best_tps_concurrency":48,"best_total_tps":38130.12746922595,"last_total_tps":25687.214694976436} +{"timestamp":"2026-07-18T19:12:37+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":4096,"osl":1024,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":7,"search_cap":512,"max_successful_concurrency":112,"saturation_concurrency":null,"stop_probe_concurrency":112,"best_tps_concurrency":48,"best_total_tps":24033.173597879653,"last_total_tps":11327.123498416522} +{"timestamp":"2026-07-18T19:26:58+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":4096,"osl":2048,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":5,"search_cap":512,"max_successful_concurrency":80,"saturation_concurrency":null,"stop_probe_concurrency":80,"best_tps_concurrency":64,"best_total_tps":15168.19077602635,"last_total_tps":10324.077501623344} +{"timestamp":"2026-07-18T19:42:52+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":4096,"osl":4096,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":4,"search_cap":512,"max_successful_concurrency":64,"saturation_concurrency":null,"stop_probe_concurrency":64,"best_tps_concurrency":64,"best_total_tps":9018.155940958604,"last_total_tps":9018.155940958604} +{"timestamp":"2026-07-18T19:45:13+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":8192,"osl":128,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_BACKOFF_FOUND","tested_points":2,"search_cap":512,"max_successful_concurrency":8,"saturation_concurrency":null,"stop_probe_concurrency":8,"best_tps_concurrency":8,"best_total_tps":69391.60199642887,"last_total_tps":69391.60199642887} +{"timestamp":"2026-07-18T19:47:41+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":8192,"osl":256,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":2,"search_cap":512,"max_successful_concurrency":32,"saturation_concurrency":null,"stop_probe_concurrency":32,"best_tps_concurrency":16,"best_total_tps":68459.44175385153,"last_total_tps":22157.355357207263} +{"timestamp":"2026-07-18T19:51:39+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":8192,"osl":512,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":3,"search_cap":512,"max_successful_concurrency":48,"saturation_concurrency":null,"stop_probe_concurrency":48,"best_tps_concurrency":32,"best_total_tps":62289.915380678285,"last_total_tps":27074.1521832791} +{"timestamp":"2026-07-18T19:56:49+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":8192,"osl":1024,"status":"COMPLETED","stop_reason":"TPS_PLATEAU","tested_points":3,"search_cap":512,"max_successful_concurrency":48,"saturation_concurrency":32,"stop_probe_concurrency":48,"best_tps_concurrency":16,"best_total_tps":28391.32676070545,"last_total_tps":22439.056068129194} +{"timestamp":"2026-07-18T20:05:59+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":8192,"osl":2048,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":3,"search_cap":512,"max_successful_concurrency":48,"saturation_concurrency":null,"stop_probe_concurrency":48,"best_tps_concurrency":32,"best_total_tps":14246.097125929868,"last_total_tps":10592.394869335376} +{"timestamp":"2026-07-18T20:10:47+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":8192,"osl":4096,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_BACKOFF_FOUND","tested_points":2,"search_cap":512,"max_successful_concurrency":8,"saturation_concurrency":null,"stop_probe_concurrency":8,"best_tps_concurrency":8,"best_total_tps":7416.610969707548,"last_total_tps":7416.610969707548} +{"timestamp":"2026-07-18T20:12:43+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":16384,"osl":128,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_BACKOFF_FOUND","tested_points":2,"search_cap":512,"max_successful_concurrency":8,"saturation_concurrency":null,"stop_probe_concurrency":8,"best_tps_concurrency":8,"best_total_tps":125755.33533321305,"last_total_tps":125755.33533321305} +{"timestamp":"2026-07-18T20:16:11+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":16384,"osl":256,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":2,"search_cap":512,"max_successful_concurrency":32,"saturation_concurrency":null,"stop_probe_concurrency":32,"best_tps_concurrency":16,"best_total_tps":126697.87934479979,"last_total_tps":23199.60017500774} +{"timestamp":"2026-07-18T20:21:20+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":16384,"osl":512,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_BACKOFF_FOUND","tested_points":3,"search_cap":512,"max_successful_concurrency":1,"saturation_concurrency":null,"stop_probe_concurrency":1,"best_tps_concurrency":1,"best_total_tps":16309.943166217838,"last_total_tps":16309.943166217838} +{"timestamp":"2026-07-18T20:24:16+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":16384,"osl":1024,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_BACKOFF_FOUND","tested_points":2,"search_cap":512,"max_successful_concurrency":8,"saturation_concurrency":null,"stop_probe_concurrency":8,"best_tps_concurrency":8,"best_total_tps":37116.415047850554,"last_total_tps":37116.415047850554} +{"timestamp":"2026-07-18T20:29:21+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":16384,"osl":2048,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":2,"search_cap":512,"max_successful_concurrency":32,"saturation_concurrency":null,"stop_probe_concurrency":32,"best_tps_concurrency":16,"best_total_tps":29677.263467656077,"last_total_tps":17243.923410293} +{"timestamp":"2026-07-18T20:37:16+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":32768,"osl":128,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_BACKOFF_FOUND","tested_points":3,"search_cap":512,"max_successful_concurrency":1,"saturation_concurrency":null,"stop_probe_concurrency":1,"best_tps_concurrency":1,"best_total_tps":12427.10553270719,"last_total_tps":12427.10553270719} +{"timestamp":"2026-07-18T20:44:54+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":32768,"osl":256,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_BACKOFF_FOUND","tested_points":3,"search_cap":512,"max_successful_concurrency":1,"saturation_concurrency":null,"stop_probe_concurrency":1,"best_tps_concurrency":16,"best_total_tps":12690.02075088378,"last_total_tps":11648.223035392135} +{"timestamp":"2026-07-18T20:52:43+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":32768,"osl":512,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_BACKOFF_FOUND","tested_points":3,"search_cap":512,"max_successful_concurrency":1,"saturation_concurrency":null,"stop_probe_concurrency":1,"best_tps_concurrency":16,"best_total_tps":12403.994325300202,"last_total_tps":10254.391874292423} +{"timestamp":"2026-07-18T21:01:05+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":32768,"osl":1024,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_BACKOFF_FOUND","tested_points":3,"search_cap":512,"max_successful_concurrency":1,"saturation_concurrency":null,"stop_probe_concurrency":1,"best_tps_concurrency":16,"best_total_tps":11992.382352227098,"last_total_tps":8229.27988033396} +{"timestamp":"2026-07-18T21:10:09+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":32768,"osl":2048,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_BACKOFF_FOUND","tested_points":3,"search_cap":512,"max_successful_concurrency":1,"saturation_concurrency":null,"stop_probe_concurrency":1,"best_tps_concurrency":16,"best_total_tps":11182.526858785568,"last_total_tps":6017.363489364099} +{"timestamp":"2026-07-18T21:24:28+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":65536,"osl":128,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":3,"search_cap":512,"max_successful_concurrency":1,"saturation_concurrency":null,"stop_probe_concurrency":1,"best_tps_concurrency":1,"best_total_tps":12338.828565909838,"last_total_tps":12338.828565909838} +{"timestamp":"2026-07-18T21:38:33+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":65536,"osl":256,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":3,"search_cap":512,"max_successful_concurrency":1,"saturation_concurrency":null,"stop_probe_concurrency":1,"best_tps_concurrency":1,"best_total_tps":11878.682996559066,"last_total_tps":11878.682996559066} +{"timestamp":"2026-07-18T21:52:53+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":65536,"osl":512,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":3,"search_cap":512,"max_successful_concurrency":1,"saturation_concurrency":null,"stop_probe_concurrency":1,"best_tps_concurrency":16,"best_total_tps":11638.508850323253,"last_total_tps":11074.078414615946} +{"timestamp":"2026-07-18T22:07:40+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":65536,"osl":1024,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":3,"search_cap":512,"max_successful_concurrency":1,"saturation_concurrency":null,"stop_probe_concurrency":1,"best_tps_concurrency":16,"best_total_tps":11425.73278736242,"last_total_tps":9696.758642433164} +{"timestamp":"2026-07-18T22:38:29+00:00","engine":"vllm","tp":8,"dp":1,"mark":"Y","isl":131072,"osl":128,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_GROUP_SKIP_THRESHOLD","tested_points":3,"search_cap":512,"max_successful_concurrency":1,"saturation_concurrency":null,"stop_probe_concurrency":1,"best_tps_concurrency":1,"best_total_tps":10979.03040593456,"last_total_tps":10979.03040593456} diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/adaptive_summary.jsonl b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/adaptive_summary.jsonl new file mode 100644 index 0000000..19b5c61 --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/adaptive_summary.jsonl @@ -0,0 +1,99 @@ +{"timestamp": "2026-07-18T05:29:14+00:00", "engine": "vllm", "tp": 2, "dp": 4, "mark": "Y", "isl": 1024, "osl": 128, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_BACKOFF_FOUND", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 1, "saturation_concurrency": null, "stop_probe_concurrency": 1, "best_tps_concurrency": 16, "best_total_tps": 3015.0735320176436, "last_total_tps": 2174.9382852560016} +{"timestamp": "2026-07-18T05:54:34+00:00", "engine": "vllm", "tp": 2, "dp": 4, "mark": "Y", "isl": 1024, "osl": 256, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 16, "search_cap": 512, "max_successful_concurrency": 256, "saturation_concurrency": null, "stop_probe_concurrency": 256, "best_tps_concurrency": 240, "best_total_tps": 22823.756401450846, "last_total_tps": 22274.270946602188} +{"timestamp": "2026-07-18T06:18:21+00:00", "engine": "vllm", "tp": 2, "dp": 4, "mark": "Y", "isl": 1024, "osl": 512, "status": "COMPLETED", "stop_reason": "TPS_PLATEAU", "tested_points": 13, "search_cap": 512, "max_successful_concurrency": 208, "saturation_concurrency": 192, "stop_probe_concurrency": 208, "best_tps_concurrency": 208, "best_total_tps": 16879.23780084254, "last_total_tps": 16879.23780084254} +{"timestamp": "2026-07-18T06:42:43+00:00", "engine": "vllm", "tp": 2, "dp": 4, "mark": "Y", "isl": 1024, "osl": 1024, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 10, "search_cap": 512, "max_successful_concurrency": 160, "saturation_concurrency": null, "stop_probe_concurrency": 160, "best_tps_concurrency": 160, "best_total_tps": 12567.806372858291, "last_total_tps": 12567.806372858291} +{"timestamp": "2026-07-18T07:15:50+00:00", "engine": "vllm", "tp": 2, "dp": 4, "mark": "Y", "isl": 1024, "osl": 2048, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 9, "search_cap": 512, "max_successful_concurrency": 144, "saturation_concurrency": null, "stop_probe_concurrency": 144, "best_tps_concurrency": 144, "best_total_tps": 10264.679524612942, "last_total_tps": 10264.679524612942} +{"timestamp": "2026-07-18T08:12:08+00:00", "engine": "vllm", "tp": 2, "dp": 4, "mark": "Y", "isl": 1024, "osl": 4096, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 9, "search_cap": 512, "max_successful_concurrency": 144, "saturation_concurrency": null, "stop_probe_concurrency": 144, "best_tps_concurrency": 144, "best_total_tps": 9644.270634946442, "last_total_tps": 9644.270634946442} +{"timestamp": "2026-07-18T08:16:06+00:00", "engine": "vllm", "tp": 2, "dp": 4, "mark": "Y", "isl": 4096, "osl": 128, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 48, "saturation_concurrency": null, "stop_probe_concurrency": 48, "best_tps_concurrency": 48, "best_total_tps": 22990.788025418202, "last_total_tps": 22990.788025418202} +{"timestamp": "2026-07-18T08:23:51+00:00", "engine": "vllm", "tp": 2, "dp": 4, "mark": "Y", "isl": 4096, "osl": 256, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 5, "search_cap": 512, "max_successful_concurrency": 80, "saturation_concurrency": null, "stop_probe_concurrency": 80, "best_tps_concurrency": 80, "best_total_tps": 26475.222191175653, "last_total_tps": 26475.222191175653} +{"timestamp": "2026-07-18T08:34:29+00:00", "engine": "vllm", "tp": 2, "dp": 4, "mark": "Y", "isl": 4096, "osl": 512, "status": "COMPLETED", "stop_reason": "TPS_PLATEAU", "tested_points": 6, "search_cap": 512, "max_successful_concurrency": 96, "saturation_concurrency": 80, "stop_probe_concurrency": 96, "best_tps_concurrency": 80, "best_total_tps": 24080.131736565483, "last_total_tps": 22767.404745722128} +{"timestamp": "2026-07-18T08:48:55+00:00", "engine": "vllm", "tp": 2, "dp": 4, "mark": "Y", "isl": 4096, "osl": 1024, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 6, "search_cap": 512, "max_successful_concurrency": 96, "saturation_concurrency": null, "stop_probe_concurrency": 96, "best_tps_concurrency": 80, "best_total_tps": 17812.993295797234, "last_total_tps": 15577.812364742018} +{"timestamp": "2026-07-18T09:02:14+00:00", "engine": "vllm", "tp": 2, "dp": 4, "mark": "Y", "isl": 4096, "osl": 2048, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 4, "search_cap": 512, "max_successful_concurrency": 64, "saturation_concurrency": null, "stop_probe_concurrency": 64, "best_tps_concurrency": 64, "best_total_tps": 11211.68138000053, "last_total_tps": 11211.68138000053} +{"timestamp": "2026-07-18T09:23:47+00:00", "engine": "vllm", "tp": 2, "dp": 4, "mark": "Y", "isl": 4096, "osl": 4096, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 4, "search_cap": 512, "max_successful_concurrency": 64, "saturation_concurrency": null, "stop_probe_concurrency": 64, "best_tps_concurrency": 64, "best_total_tps": 8406.252728727331, "last_total_tps": 8406.252728727331} +{"timestamp": "2026-07-18T09:25:57+00:00", "engine": "vllm", "tp": 2, "dp": 4, "mark": "Y", "isl": 8192, "osl": 128, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_BACKOFF_FOUND", "tested_points": 2, "search_cap": 512, "max_successful_concurrency": 8, "saturation_concurrency": null, "stop_probe_concurrency": 8, "best_tps_concurrency": 16, "best_total_tps": 22475.134272625077, "last_total_tps": 17103.958134486435} +{"timestamp": "2026-07-18T09:28:57+00:00", "engine": "vllm", "tp": 2, "dp": 4, "mark": "Y", "isl": 8192, "osl": 256, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 2, "search_cap": 512, "max_successful_concurrency": 32, "saturation_concurrency": null, "stop_probe_concurrency": 32, "best_tps_concurrency": 32, "best_total_tps": 22539.211705624853, "last_total_tps": 22539.211705624853} +{"timestamp": "2026-07-18T09:34:58+00:00", "engine": "vllm", "tp": 2, "dp": 4, "mark": "Y", "isl": 8192, "osl": 512, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 48, "saturation_concurrency": null, "stop_probe_concurrency": 48, "best_tps_concurrency": 48, "best_total_tps": 18690.72143294463, "last_total_tps": 18690.72143294463} +{"timestamp": "2026-07-18T09:45:26+00:00", "engine": "vllm", "tp": 2, "dp": 4, "mark": "Y", "isl": 8192, "osl": 1024, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 4, "search_cap": 512, "max_successful_concurrency": 64, "saturation_concurrency": null, "stop_probe_concurrency": 64, "best_tps_concurrency": 32, "best_total_tps": 17720.008987633595, "last_total_tps": 17096.31387964654} +{"timestamp": "2026-07-18T09:52:23+00:00", "engine": "vllm", "tp": 2, "dp": 4, "mark": "Y", "isl": 8192, "osl": 2048, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 2, "search_cap": 512, "max_successful_concurrency": 32, "saturation_concurrency": null, "stop_probe_concurrency": 32, "best_tps_concurrency": 32, "best_total_tps": 9893.374561568064, "last_total_tps": 9893.374561568064} +{"timestamp": "2026-07-18T10:10:27+00:00", "engine": "vllm", "tp": 2, "dp": 4, "mark": "Y", "isl": 8192, "osl": 4096, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 48, "saturation_concurrency": null, "stop_probe_concurrency": 48, "best_tps_concurrency": 32, "best_total_tps": 7752.108917909322, "last_total_tps": 7707.917754293005} +{"timestamp": "2026-07-18T10:14:08+00:00", "engine": "vllm", "tp": 2, "dp": 4, "mark": "Y", "isl": 16384, "osl": 128, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_BACKOFF_FOUND", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 1, "saturation_concurrency": null, "stop_probe_concurrency": 1, "best_tps_concurrency": 8, "best_total_tps": 24865.616658934323, "last_total_tps": 11122.032460750675} +{"timestamp": "2026-07-18T10:17:49+00:00", "engine": "vllm", "tp": 2, "dp": 4, "mark": "Y", "isl": 16384, "osl": 256, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_BACKOFF_FOUND", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 1, "saturation_concurrency": null, "stop_probe_concurrency": 1, "best_tps_concurrency": 16, "best_total_tps": 23012.01710741807, "last_total_tps": 15887.249318921436} +{"timestamp": "2026-07-18T10:21:02+00:00", "engine": "vllm", "tp": 2, "dp": 4, "mark": "Y", "isl": 16384, "osl": 512, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_BACKOFF_FOUND", "tested_points": 2, "search_cap": 512, "max_successful_concurrency": 8, "saturation_concurrency": null, "stop_probe_concurrency": 8, "best_tps_concurrency": 16, "best_total_tps": 19442.486909391213, "last_total_tps": 18631.350055538867} +{"timestamp": "2026-07-18T10:26:36+00:00", "engine": "vllm", "tp": 2, "dp": 4, "mark": "Y", "isl": 16384, "osl": 1024, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 2, "search_cap": 512, "max_successful_concurrency": 32, "saturation_concurrency": null, "stop_probe_concurrency": 32, "best_tps_concurrency": 16, "best_total_tps": 17326.656171496328, "last_total_tps": 16664.646127980955} +{"timestamp": "2026-07-18T10:33:30+00:00", "engine": "vllm", "tp": 2, "dp": 4, "mark": "Y", "isl": 16384, "osl": 2048, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 2, "search_cap": 512, "max_successful_concurrency": 32, "saturation_concurrency": null, "stop_probe_concurrency": 32, "best_tps_concurrency": 16, "best_total_tps": 13951.617144820304, "last_total_tps": 13577.5608045342} +{"timestamp": "2026-07-18T10:38:51+00:00", "engine": "vllm", "tp": 2, "dp": 4, "mark": "Y", "isl": 32768, "osl": 128, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_BACKOFF_FOUND", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 1, "saturation_concurrency": null, "stop_probe_concurrency": 1, "best_tps_concurrency": 16, "best_total_tps": 24027.01351446888, "last_total_tps": 10012.090128383596} +{"timestamp": "2026-07-18T10:43:53+00:00", "engine": "vllm", "tp": 2, "dp": 4, "mark": "Y", "isl": 32768, "osl": 256, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_BACKOFF_FOUND", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 1, "saturation_concurrency": null, "stop_probe_concurrency": 1, "best_tps_concurrency": 8, "best_total_tps": 31754.471763504465, "last_total_tps": 14216.435608892436} +{"timestamp": "2026-07-18T10:49:00+00:00", "engine": "vllm", "tp": 2, "dp": 4, "mark": "Y", "isl": 32768, "osl": 512, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_BACKOFF_FOUND", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 1, "saturation_concurrency": null, "stop_probe_concurrency": 1, "best_tps_concurrency": 16, "best_total_tps": 21601.934455438146, "last_total_tps": 20658.797131822408} +{"timestamp": "2026-07-18T10:55:38+00:00", "engine": "vllm", "tp": 2, "dp": 4, "mark": "Y", "isl": 32768, "osl": 1024, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_BACKOFF_FOUND", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 1, "saturation_concurrency": null, "stop_probe_concurrency": 1, "best_tps_concurrency": 8, "best_total_tps": 16002.913115323085, "last_total_tps": 8422.91731241034} +{"timestamp": "2026-07-18T11:04:00+00:00", "engine": "vllm", "tp": 2, "dp": 4, "mark": "Y", "isl": 32768, "osl": 2048, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_BACKOFF_FOUND", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 1, "saturation_concurrency": null, "stop_probe_concurrency": 1, "best_tps_concurrency": 8, "best_total_tps": 13118.917606193083, "last_total_tps": 4303.257993236072} +{"timestamp": "2026-07-18T11:13:43+00:00", "engine": "vllm", "tp": 2, "dp": 4, "mark": "Y", "isl": 65536, "osl": 128, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 1, "saturation_concurrency": null, "stop_probe_concurrency": 1, "best_tps_concurrency": 16, "best_total_tps": 22082.39716918432, "last_total_tps": 12976.971644142252} +{"timestamp": "2026-07-18T11:23:26+00:00", "engine": "vllm", "tp": 2, "dp": 4, "mark": "Y", "isl": 65536, "osl": 256, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 1, "saturation_concurrency": null, "stop_probe_concurrency": 1, "best_tps_concurrency": 16, "best_total_tps": 21391.62354069105, "last_total_tps": 9648.08002379338} +{"timestamp": "2026-07-18T11:34:07+00:00", "engine": "vllm", "tp": 2, "dp": 4, "mark": "Y", "isl": 65536, "osl": 512, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 1, "saturation_concurrency": null, "stop_probe_concurrency": 1, "best_tps_concurrency": 16, "best_total_tps": 18380.036907849004, "last_total_tps": 8694.767469837296} +{"timestamp": "2026-07-18T11:46:01+00:00", "engine": "vllm", "tp": 2, "dp": 4, "mark": "Y", "isl": 65536, "osl": 1024, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 1, "saturation_concurrency": null, "stop_probe_concurrency": 1, "best_tps_concurrency": 16, "best_total_tps": 15690.052427755394, "last_total_tps": 11290.434955219338} +{"timestamp": "2026-07-18T12:05:17+00:00", "engine": "vllm", "tp": 2, "dp": 4, "mark": "Y", "isl": 131072, "osl": 128, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_GROUP_SKIP_THRESHOLD", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 1, "saturation_concurrency": null, "stop_probe_concurrency": 1, "best_tps_concurrency": 16, "best_total_tps": 19183.73328417493, "last_total_tps": 7492.046543774283} +{"timestamp": "2026-07-18T12:20:35+00:00", "engine": "vllm", "tp": 4, "dp": 2, "mark": "Y", "isl": 1024, "osl": 128, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_BACKOFF_FOUND", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 1, "saturation_concurrency": null, "stop_probe_concurrency": 1, "best_tps_concurrency": 16, "best_total_tps": 3344.8590600064417, "last_total_tps": 3105.1557066813575} +{"timestamp": "2026-07-18T12:22:56+00:00", "engine": "vllm", "tp": 4, "dp": 2, "mark": "Y", "isl": 1024, "osl": 256, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 2, "search_cap": 512, "max_successful_concurrency": 32, "saturation_concurrency": null, "stop_probe_concurrency": 32, "best_tps_concurrency": 32, "best_total_tps": 6548.10995313187, "last_total_tps": 6548.10995313187} +{"timestamp": "2026-07-18T12:25:15+00:00", "engine": "vllm", "tp": 4, "dp": 2, "mark": "Y", "isl": 1024, "osl": 512, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_BACKOFF_FOUND", "tested_points": 2, "search_cap": 512, "max_successful_concurrency": 8, "saturation_concurrency": null, "stop_probe_concurrency": 8, "best_tps_concurrency": 16, "best_total_tps": 3752.4892505307353, "last_total_tps": 2351.8356531240383} +{"timestamp": "2026-07-18T12:30:27+00:00", "engine": "vllm", "tp": 4, "dp": 2, "mark": "Y", "isl": 1024, "osl": 1024, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 48, "saturation_concurrency": null, "stop_probe_concurrency": 48, "best_tps_concurrency": 48, "best_total_tps": 6282.932443000561, "last_total_tps": 6282.932443000561} +{"timestamp": "2026-07-18T13:00:40+00:00", "engine": "vllm", "tp": 4, "dp": 2, "mark": "Y", "isl": 1024, "osl": 2048, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 9, "search_cap": 512, "max_successful_concurrency": 144, "saturation_concurrency": null, "stop_probe_concurrency": 144, "best_tps_concurrency": 144, "best_total_tps": 10013.653613623694, "last_total_tps": 10013.653613623694} +{"timestamp": "2026-07-18T13:37:21+00:00", "engine": "vllm", "tp": 4, "dp": 2, "mark": "Y", "isl": 1024, "osl": 4096, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 7, "search_cap": 512, "max_successful_concurrency": 112, "saturation_concurrency": null, "stop_probe_concurrency": 112, "best_tps_concurrency": 112, "best_total_tps": 8005.974972196393, "last_total_tps": 8005.974972196393} +{"timestamp": "2026-07-18T13:39:39+00:00", "engine": "vllm", "tp": 4, "dp": 2, "mark": "Y", "isl": 4096, "osl": 128, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 2, "search_cap": 512, "max_successful_concurrency": 32, "saturation_concurrency": null, "stop_probe_concurrency": 32, "best_tps_concurrency": 32, "best_total_tps": 19178.900984274085, "last_total_tps": 19178.900984274085} +{"timestamp": "2026-07-18T13:44:54+00:00", "engine": "vllm", "tp": 4, "dp": 2, "mark": "Y", "isl": 4096, "osl": 256, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 4, "search_cap": 512, "max_successful_concurrency": 64, "saturation_concurrency": null, "stop_probe_concurrency": 64, "best_tps_concurrency": 64, "best_total_tps": 24635.58080407481, "last_total_tps": 24635.58080407481} +{"timestamp": "2026-07-18T13:56:47+00:00", "engine": "vllm", "tp": 4, "dp": 2, "mark": "Y", "isl": 4096, "osl": 512, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 7, "search_cap": 512, "max_successful_concurrency": 112, "saturation_concurrency": null, "stop_probe_concurrency": 112, "best_tps_concurrency": 48, "best_total_tps": 27810.19370932178, "last_total_tps": 25413.33859287685} +{"timestamp": "2026-07-18T14:07:21+00:00", "engine": "vllm", "tp": 4, "dp": 2, "mark": "Y", "isl": 4096, "osl": 1024, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 5, "search_cap": 512, "max_successful_concurrency": 80, "saturation_concurrency": null, "stop_probe_concurrency": 80, "best_tps_concurrency": 80, "best_total_tps": 17567.35396640895, "last_total_tps": 17567.35396640895} +{"timestamp": "2026-07-18T14:23:11+00:00", "engine": "vllm", "tp": 4, "dp": 2, "mark": "Y", "isl": 4096, "osl": 2048, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 5, "search_cap": 512, "max_successful_concurrency": 80, "saturation_concurrency": null, "stop_probe_concurrency": 80, "best_tps_concurrency": 64, "best_total_tps": 12739.402829165518, "last_total_tps": 12095.484089529828} +{"timestamp": "2026-07-18T14:33:27+00:00", "engine": "vllm", "tp": 4, "dp": 2, "mark": "Y", "isl": 4096, "osl": 4096, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 2, "search_cap": 512, "max_successful_concurrency": 32, "saturation_concurrency": null, "stop_probe_concurrency": 32, "best_tps_concurrency": 32, "best_total_tps": 4580.400381472649, "last_total_tps": 4580.400381472649} +{"timestamp": "2026-07-18T14:35:41+00:00", "engine": "vllm", "tp": 4, "dp": 2, "mark": "Y", "isl": 8192, "osl": 128, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 2, "search_cap": 512, "max_successful_concurrency": 32, "saturation_concurrency": null, "stop_probe_concurrency": 32, "best_tps_concurrency": 32, "best_total_tps": 39853.46551460155, "last_total_tps": 39853.46551460155} +{"timestamp": "2026-07-18T14:39:41+00:00", "engine": "vllm", "tp": 4, "dp": 2, "mark": "Y", "isl": 8192, "osl": 256, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 48, "saturation_concurrency": null, "stop_probe_concurrency": 48, "best_tps_concurrency": 32, "best_total_tps": 42569.34108492768, "last_total_tps": 31967.098642717658} +{"timestamp": "2026-07-18T14:46:04+00:00", "engine": "vllm", "tp": 4, "dp": 2, "mark": "Y", "isl": 8192, "osl": 512, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 4, "search_cap": 512, "max_successful_concurrency": 64, "saturation_concurrency": null, "stop_probe_concurrency": 64, "best_tps_concurrency": 48, "best_total_tps": 39561.92047849611, "last_total_tps": 28912.961345619125} +{"timestamp": "2026-07-18T14:49:49+00:00", "engine": "vllm", "tp": 4, "dp": 2, "mark": "Y", "isl": 8192, "osl": 1024, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 2, "search_cap": 512, "max_successful_concurrency": 32, "saturation_concurrency": null, "stop_probe_concurrency": 32, "best_tps_concurrency": 32, "best_total_tps": 19481.210961119526, "last_total_tps": 19481.210961119526} +{"timestamp": "2026-07-18T15:02:28+00:00", "engine": "vllm", "tp": 4, "dp": 2, "mark": "Y", "isl": 8192, "osl": 2048, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 4, "search_cap": 512, "max_successful_concurrency": 64, "saturation_concurrency": null, "stop_probe_concurrency": 64, "best_tps_concurrency": 48, "best_total_tps": 14382.678920590475, "last_total_tps": 14183.722585941723} +{"timestamp": "2026-07-18T15:10:11+00:00", "engine": "vllm", "tp": 4, "dp": 2, "mark": "Y", "isl": 8192, "osl": 4096, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_BACKOFF_FOUND", "tested_points": 2, "search_cap": 512, "max_successful_concurrency": 8, "saturation_concurrency": null, "stop_probe_concurrency": 8, "best_tps_concurrency": 16, "best_total_tps": 6412.76920954965, "last_total_tps": 2138.181531776794} +{"timestamp": "2026-07-18T15:13:40+00:00", "engine": "vllm", "tp": 4, "dp": 2, "mark": "Y", "isl": 16384, "osl": 128, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_BACKOFF_FOUND", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 1, "saturation_concurrency": null, "stop_probe_concurrency": 1, "best_tps_concurrency": 1, "best_total_tps": 33408.61928165981, "last_total_tps": 33408.61928165981} +{"timestamp": "2026-07-18T15:15:44+00:00", "engine": "vllm", "tp": 4, "dp": 2, "mark": "Y", "isl": 16384, "osl": 256, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_BACKOFF_FOUND", "tested_points": 2, "search_cap": 512, "max_successful_concurrency": 8, "saturation_concurrency": null, "stop_probe_concurrency": 8, "best_tps_concurrency": 8, "best_total_tps": 50503.577165846604, "last_total_tps": 50503.577165846604} +{"timestamp": "2026-07-18T15:18:23+00:00", "engine": "vllm", "tp": 4, "dp": 2, "mark": "Y", "isl": 16384, "osl": 512, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_BACKOFF_FOUND", "tested_points": 2, "search_cap": 512, "max_successful_concurrency": 8, "saturation_concurrency": null, "stop_probe_concurrency": 8, "best_tps_concurrency": 16, "best_total_tps": 30999.559317019954, "last_total_tps": 26123.82918959831} +{"timestamp": "2026-07-18T15:22:44+00:00", "engine": "vllm", "tp": 4, "dp": 2, "mark": "Y", "isl": 16384, "osl": 1024, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 2, "search_cap": 512, "max_successful_concurrency": 32, "saturation_concurrency": null, "stop_probe_concurrency": 32, "best_tps_concurrency": 16, "best_total_tps": 32508.7078149849, "last_total_tps": 20577.25215102256} +{"timestamp": "2026-07-18T15:30:35+00:00", "engine": "vllm", "tp": 4, "dp": 2, "mark": "Y", "isl": 16384, "osl": 2048, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 2, "search_cap": 512, "max_successful_concurrency": 32, "saturation_concurrency": null, "stop_probe_concurrency": 32, "best_tps_concurrency": 32, "best_total_tps": 11633.976050505793, "last_total_tps": 11633.976050505793} +{"timestamp": "2026-07-18T15:36:59+00:00", "engine": "vllm", "tp": 4, "dp": 2, "mark": "Y", "isl": 32768, "osl": 128, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_BACKOFF_FOUND", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 1, "saturation_concurrency": null, "stop_probe_concurrency": 1, "best_tps_concurrency": 1, "best_total_tps": 27287.043986532444, "last_total_tps": 27287.043986532444} +{"timestamp": "2026-07-18T15:43:07+00:00", "engine": "vllm", "tp": 4, "dp": 2, "mark": "Y", "isl": 32768, "osl": 256, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_BACKOFF_FOUND", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 1, "saturation_concurrency": null, "stop_probe_concurrency": 1, "best_tps_concurrency": 1, "best_total_tps": 23358.28664193622, "last_total_tps": 23358.28664193622} +{"timestamp": "2026-07-18T15:49:39+00:00", "engine": "vllm", "tp": 4, "dp": 2, "mark": "Y", "isl": 32768, "osl": 512, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_BACKOFF_FOUND", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 1, "saturation_concurrency": null, "stop_probe_concurrency": 1, "best_tps_concurrency": 16, "best_total_tps": 18569.10902612545, "last_total_tps": 9111.296968823292} +{"timestamp": "2026-07-18T15:57:12+00:00", "engine": "vllm", "tp": 4, "dp": 2, "mark": "Y", "isl": 32768, "osl": 1024, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_BACKOFF_FOUND", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 1, "saturation_concurrency": null, "stop_probe_concurrency": 1, "best_tps_concurrency": 16, "best_total_tps": 14748.417896491363, "last_total_tps": 9673.325803607086} +{"timestamp": "2026-07-18T16:05:47+00:00", "engine": "vllm", "tp": 4, "dp": 2, "mark": "Y", "isl": 32768, "osl": 2048, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_BACKOFF_FOUND", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 1, "saturation_concurrency": null, "stop_probe_concurrency": 1, "best_tps_concurrency": 16, "best_total_tps": 15083.518350142393, "last_total_tps": 6269.492442147328} +{"timestamp": "2026-07-18T16:16:34+00:00", "engine": "vllm", "tp": 4, "dp": 2, "mark": "Y", "isl": 65536, "osl": 128, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 1, "saturation_concurrency": null, "stop_probe_concurrency": 1, "best_tps_concurrency": 16, "best_total_tps": 18097.595470378677, "last_total_tps": 9234.20143323196} +{"timestamp": "2026-07-18T16:27:52+00:00", "engine": "vllm", "tp": 4, "dp": 2, "mark": "Y", "isl": 65536, "osl": 256, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 1, "saturation_concurrency": null, "stop_probe_concurrency": 1, "best_tps_concurrency": 16, "best_total_tps": 16346.160186620771, "last_total_tps": 8944.957286178149} +{"timestamp": "2026-07-18T16:40:02+00:00", "engine": "vllm", "tp": 4, "dp": 2, "mark": "Y", "isl": 65536, "osl": 512, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 1, "saturation_concurrency": null, "stop_probe_concurrency": 1, "best_tps_concurrency": 16, "best_total_tps": 14751.439899006828, "last_total_tps": 8379.130790916777} +{"timestamp": "2026-07-18T16:53:14+00:00", "engine": "vllm", "tp": 4, "dp": 2, "mark": "Y", "isl": 65536, "osl": 1024, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 1, "saturation_concurrency": null, "stop_probe_concurrency": 1, "best_tps_concurrency": 16, "best_total_tps": 14436.120234197522, "last_total_tps": 7485.43284228809} +{"timestamp": "2026-07-18T17:15:45+00:00", "engine": "vllm", "tp": 4, "dp": 2, "mark": "Y", "isl": 131072, "osl": 128, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_GROUP_SKIP_THRESHOLD", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 1, "saturation_concurrency": null, "stop_probe_concurrency": 1, "best_tps_concurrency": 8, "best_total_tps": 14275.478163292184, "last_total_tps": 8262.033751699666} +{"timestamp": "2026-07-18T17:30:21+00:00", "engine": "vllm", "tp": 8, "dp": 1, "mark": "Y", "isl": 1024, "osl": 128, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_BACKOFF_FOUND", "tested_points": 2, "search_cap": 512, "max_successful_concurrency": 8, "saturation_concurrency": null, "stop_probe_concurrency": 8, "best_tps_concurrency": 8, "best_total_tps": 10025.042822339861, "last_total_tps": 10025.042822339861} +{"timestamp": "2026-07-18T17:37:20+00:00", "engine": "vllm", "tp": 8, "dp": 1, "mark": "Y", "isl": 1024, "osl": 256, "status": "COMPLETED", "stop_reason": "TPS_PLATEAU", "tested_points": 6, "search_cap": 512, "max_successful_concurrency": 96, "saturation_concurrency": 80, "stop_probe_concurrency": 96, "best_tps_concurrency": 64, "best_total_tps": 15042.006973739983, "last_total_tps": 13845.874509801075} +{"timestamp": "2026-07-18T17:47:07+00:00", "engine": "vllm", "tp": 8, "dp": 1, "mark": "Y", "isl": 1024, "osl": 512, "status": "COMPLETED", "stop_reason": "TPS_PLATEAU", "tested_points": 7, "search_cap": 512, "max_successful_concurrency": 112, "saturation_concurrency": 96, "stop_probe_concurrency": 112, "best_tps_concurrency": 80, "best_total_tps": 14896.170124755301, "last_total_tps": 10795.07855914963} +{"timestamp": "2026-07-18T18:06:38+00:00", "engine": "vllm", "tp": 8, "dp": 1, "mark": "Y", "isl": 1024, "osl": 1024, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 9, "search_cap": 512, "max_successful_concurrency": 144, "saturation_concurrency": null, "stop_probe_concurrency": 144, "best_tps_concurrency": 80, "best_total_tps": 10780.359050625337, "last_total_tps": 9446.638839430734} +{"timestamp": "2026-07-18T18:27:39+00:00", "engine": "vllm", "tp": 8, "dp": 1, "mark": "Y", "isl": 1024, "osl": 2048, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 7, "search_cap": 512, "max_successful_concurrency": 112, "saturation_concurrency": null, "stop_probe_concurrency": 112, "best_tps_concurrency": 80, "best_total_tps": 9194.780039334513, "last_total_tps": 6468.653255749296} +{"timestamp": "2026-07-18T18:46:10+00:00", "engine": "vllm", "tp": 8, "dp": 1, "mark": "Y", "isl": 1024, "osl": 4096, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 5, "search_cap": 512, "max_successful_concurrency": 80, "saturation_concurrency": null, "stop_probe_concurrency": 80, "best_tps_concurrency": 80, "best_total_tps": 7765.878131868169, "last_total_tps": 7765.878131868169} +{"timestamp": "2026-07-18T18:48:27+00:00", "engine": "vllm", "tp": 8, "dp": 1, "mark": "Y", "isl": 4096, "osl": 128, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 2, "search_cap": 512, "max_successful_concurrency": 32, "saturation_concurrency": null, "stop_probe_concurrency": 32, "best_tps_concurrency": 32, "best_total_tps": 21699.142108086646, "last_total_tps": 21699.142108086646} +{"timestamp": "2026-07-18T18:51:36+00:00", "engine": "vllm", "tp": 8, "dp": 1, "mark": "Y", "isl": 4096, "osl": 256, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 48, "saturation_concurrency": null, "stop_probe_concurrency": 48, "best_tps_concurrency": 32, "best_total_tps": 49644.3174513865, "last_total_tps": 26136.671923171692} +{"timestamp": "2026-07-18T18:56:21+00:00", "engine": "vllm", "tp": 8, "dp": 1, "mark": "Y", "isl": 4096, "osl": 512, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 4, "search_cap": 512, "max_successful_concurrency": 64, "saturation_concurrency": null, "stop_probe_concurrency": 64, "best_tps_concurrency": 48, "best_total_tps": 38130.12746922595, "last_total_tps": 25687.214694976436} +{"timestamp": "2026-07-18T19:12:37+00:00", "engine": "vllm", "tp": 8, "dp": 1, "mark": "Y", "isl": 4096, "osl": 1024, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 7, "search_cap": 512, "max_successful_concurrency": 112, "saturation_concurrency": null, "stop_probe_concurrency": 112, "best_tps_concurrency": 48, "best_total_tps": 24033.173597879653, "last_total_tps": 11327.123498416522} +{"timestamp": "2026-07-18T19:26:58+00:00", "engine": "vllm", "tp": 8, "dp": 1, "mark": "Y", "isl": 4096, "osl": 2048, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 5, "search_cap": 512, "max_successful_concurrency": 80, "saturation_concurrency": null, "stop_probe_concurrency": 80, "best_tps_concurrency": 64, "best_total_tps": 15168.19077602635, "last_total_tps": 10324.077501623344} +{"timestamp": "2026-07-18T19:42:52+00:00", "engine": "vllm", "tp": 8, "dp": 1, "mark": "Y", "isl": 4096, "osl": 4096, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 4, "search_cap": 512, "max_successful_concurrency": 64, "saturation_concurrency": null, "stop_probe_concurrency": 64, "best_tps_concurrency": 64, "best_total_tps": 9018.155940958604, "last_total_tps": 9018.155940958604} +{"timestamp": "2026-07-18T19:45:13+00:00", "engine": "vllm", "tp": 8, "dp": 1, "mark": "Y", "isl": 8192, "osl": 128, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_BACKOFF_FOUND", "tested_points": 2, "search_cap": 512, "max_successful_concurrency": 8, "saturation_concurrency": null, "stop_probe_concurrency": 8, "best_tps_concurrency": 8, "best_total_tps": 69391.60199642887, "last_total_tps": 69391.60199642887} +{"timestamp": "2026-07-18T19:47:41+00:00", "engine": "vllm", "tp": 8, "dp": 1, "mark": "Y", "isl": 8192, "osl": 256, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 2, "search_cap": 512, "max_successful_concurrency": 32, "saturation_concurrency": null, "stop_probe_concurrency": 32, "best_tps_concurrency": 16, "best_total_tps": 68459.44175385153, "last_total_tps": 22157.355357207263} +{"timestamp": "2026-07-18T19:51:39+00:00", "engine": "vllm", "tp": 8, "dp": 1, "mark": "Y", "isl": 8192, "osl": 512, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 48, "saturation_concurrency": null, "stop_probe_concurrency": 48, "best_tps_concurrency": 32, "best_total_tps": 62289.915380678285, "last_total_tps": 27074.1521832791} +{"timestamp": "2026-07-18T19:56:49+00:00", "engine": "vllm", "tp": 8, "dp": 1, "mark": "Y", "isl": 8192, "osl": 1024, "status": "COMPLETED", "stop_reason": "TPS_PLATEAU", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 48, "saturation_concurrency": 32, "stop_probe_concurrency": 48, "best_tps_concurrency": 16, "best_total_tps": 28391.32676070545, "last_total_tps": 22439.056068129194} +{"timestamp": "2026-07-18T20:05:59+00:00", "engine": "vllm", "tp": 8, "dp": 1, "mark": "Y", "isl": 8192, "osl": 2048, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 48, "saturation_concurrency": null, "stop_probe_concurrency": 48, "best_tps_concurrency": 32, "best_total_tps": 14246.097125929868, "last_total_tps": 10592.394869335376} +{"timestamp": "2026-07-18T20:10:47+00:00", "engine": "vllm", "tp": 8, "dp": 1, "mark": "Y", "isl": 8192, "osl": 4096, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_BACKOFF_FOUND", "tested_points": 2, "search_cap": 512, "max_successful_concurrency": 8, "saturation_concurrency": null, "stop_probe_concurrency": 8, "best_tps_concurrency": 8, "best_total_tps": 7416.610969707548, "last_total_tps": 7416.610969707548} +{"timestamp": "2026-07-18T20:12:43+00:00", "engine": "vllm", "tp": 8, "dp": 1, "mark": "Y", "isl": 16384, "osl": 128, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_BACKOFF_FOUND", "tested_points": 2, "search_cap": 512, "max_successful_concurrency": 8, "saturation_concurrency": null, "stop_probe_concurrency": 8, "best_tps_concurrency": 8, "best_total_tps": 125755.33533321305, "last_total_tps": 125755.33533321305} +{"timestamp": "2026-07-18T20:16:11+00:00", "engine": "vllm", "tp": 8, "dp": 1, "mark": "Y", "isl": 16384, "osl": 256, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 2, "search_cap": 512, "max_successful_concurrency": 32, "saturation_concurrency": null, "stop_probe_concurrency": 32, "best_tps_concurrency": 16, "best_total_tps": 126697.87934479979, "last_total_tps": 23199.60017500774} +{"timestamp": "2026-07-18T20:21:20+00:00", "engine": "vllm", "tp": 8, "dp": 1, "mark": "Y", "isl": 16384, "osl": 512, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_BACKOFF_FOUND", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 1, "saturation_concurrency": null, "stop_probe_concurrency": 1, "best_tps_concurrency": 1, "best_total_tps": 16309.943166217838, "last_total_tps": 16309.943166217838} +{"timestamp": "2026-07-18T20:24:16+00:00", "engine": "vllm", "tp": 8, "dp": 1, "mark": "Y", "isl": 16384, "osl": 1024, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_BACKOFF_FOUND", "tested_points": 2, "search_cap": 512, "max_successful_concurrency": 8, "saturation_concurrency": null, "stop_probe_concurrency": 8, "best_tps_concurrency": 8, "best_total_tps": 37116.415047850554, "last_total_tps": 37116.415047850554} +{"timestamp": "2026-07-18T20:29:21+00:00", "engine": "vllm", "tp": 8, "dp": 1, "mark": "Y", "isl": 16384, "osl": 2048, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 2, "search_cap": 512, "max_successful_concurrency": 32, "saturation_concurrency": null, "stop_probe_concurrency": 32, "best_tps_concurrency": 16, "best_total_tps": 29677.263467656077, "last_total_tps": 17243.923410293} +{"timestamp": "2026-07-18T20:37:16+00:00", "engine": "vllm", "tp": 8, "dp": 1, "mark": "Y", "isl": 32768, "osl": 128, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_BACKOFF_FOUND", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 1, "saturation_concurrency": null, "stop_probe_concurrency": 1, "best_tps_concurrency": 1, "best_total_tps": 12427.10553270719, "last_total_tps": 12427.10553270719} +{"timestamp": "2026-07-18T20:44:54+00:00", "engine": "vllm", "tp": 8, "dp": 1, "mark": "Y", "isl": 32768, "osl": 256, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_BACKOFF_FOUND", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 1, "saturation_concurrency": null, "stop_probe_concurrency": 1, "best_tps_concurrency": 16, "best_total_tps": 12690.02075088378, "last_total_tps": 11648.223035392135} +{"timestamp": "2026-07-18T20:52:43+00:00", "engine": "vllm", "tp": 8, "dp": 1, "mark": "Y", "isl": 32768, "osl": 512, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_BACKOFF_FOUND", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 1, "saturation_concurrency": null, "stop_probe_concurrency": 1, "best_tps_concurrency": 16, "best_total_tps": 12403.994325300202, "last_total_tps": 10254.391874292423} +{"timestamp": "2026-07-18T21:01:05+00:00", "engine": "vllm", "tp": 8, "dp": 1, "mark": "Y", "isl": 32768, "osl": 1024, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_BACKOFF_FOUND", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 1, "saturation_concurrency": null, "stop_probe_concurrency": 1, "best_tps_concurrency": 16, "best_total_tps": 11992.382352227098, "last_total_tps": 8229.27988033396} +{"timestamp": "2026-07-18T21:10:09+00:00", "engine": "vllm", "tp": 8, "dp": 1, "mark": "Y", "isl": 32768, "osl": 2048, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_BACKOFF_FOUND", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 1, "saturation_concurrency": null, "stop_probe_concurrency": 1, "best_tps_concurrency": 16, "best_total_tps": 11182.526858785568, "last_total_tps": 6017.363489364099} +{"timestamp": "2026-07-18T21:24:28+00:00", "engine": "vllm", "tp": 8, "dp": 1, "mark": "Y", "isl": 65536, "osl": 128, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 1, "saturation_concurrency": null, "stop_probe_concurrency": 1, "best_tps_concurrency": 1, "best_total_tps": 12338.828565909838, "last_total_tps": 12338.828565909838} +{"timestamp": "2026-07-18T21:38:33+00:00", "engine": "vllm", "tp": 8, "dp": 1, "mark": "Y", "isl": 65536, "osl": 256, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 1, "saturation_concurrency": null, "stop_probe_concurrency": 1, "best_tps_concurrency": 1, "best_total_tps": 11878.682996559066, "last_total_tps": 11878.682996559066} +{"timestamp": "2026-07-18T21:52:53+00:00", "engine": "vllm", "tp": 8, "dp": 1, "mark": "Y", "isl": 65536, "osl": 512, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 1, "saturation_concurrency": null, "stop_probe_concurrency": 1, "best_tps_concurrency": 16, "best_total_tps": 11638.508850323253, "last_total_tps": 11074.078414615946} +{"timestamp": "2026-07-18T22:07:40+00:00", "engine": "vllm", "tp": 8, "dp": 1, "mark": "Y", "isl": 65536, "osl": 1024, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 1, "saturation_concurrency": null, "stop_probe_concurrency": 1, "best_tps_concurrency": 16, "best_total_tps": 11425.73278736242, "last_total_tps": 9696.758642433164} +{"timestamp": "2026-07-18T22:38:29+00:00", "engine": "vllm", "tp": 8, "dp": 1, "mark": "Y", "isl": 131072, "osl": 128, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_GROUP_SKIP_THRESHOLD", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 1, "saturation_concurrency": null, "stop_probe_concurrency": 1, "best_tps_concurrency": 1, "best_total_tps": 10979.03040593456, "last_total_tps": 10979.03040593456} diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/adaptive_summary.md b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/adaptive_summary.md new file mode 100644 index 0000000..02babb8 --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/adaptive_summary.md @@ -0,0 +1,105 @@ +# Adaptive concurrency search summary + +| Engine | TP | DP | ISL | OSL | Stop | Saturation C | Best TPS C | Best Total TPS | Max successful C | +|---|---:|---:|---:|---:|---|---:|---:|---:|---:| +| vllm | 2 | 4 | 1024 | 128 | TTFT_SLO_BACKOFF_FOUND | None | 16 | 3015.0735320176436 | 1 | +| vllm | 2 | 4 | 1024 | 256 | TTFT_SLO_EXCEEDED | None | 240 | 22823.756401450846 | 256 | +| vllm | 2 | 4 | 1024 | 512 | TPS_PLATEAU | 192 | 208 | 16879.23780084254 | 208 | +| vllm | 2 | 4 | 1024 | 1024 | TTFT_SLO_EXCEEDED | None | 160 | 12567.806372858291 | 160 | +| vllm | 2 | 4 | 1024 | 2048 | TTFT_SLO_EXCEEDED | None | 144 | 10264.679524612942 | 144 | +| vllm | 2 | 4 | 1024 | 4096 | TTFT_SLO_EXCEEDED | None | 144 | 9644.270634946442 | 144 | +| vllm | 2 | 4 | 4096 | 128 | TTFT_SLO_EXCEEDED | None | 48 | 22990.788025418202 | 48 | +| vllm | 2 | 4 | 4096 | 256 | TTFT_SLO_EXCEEDED | None | 80 | 26475.222191175653 | 80 | +| vllm | 2 | 4 | 4096 | 512 | TPS_PLATEAU | 80 | 80 | 24080.131736565483 | 96 | +| vllm | 2 | 4 | 4096 | 1024 | TTFT_SLO_EXCEEDED | None | 80 | 17812.993295797234 | 96 | +| vllm | 2 | 4 | 4096 | 2048 | TTFT_SLO_EXCEEDED | None | 64 | 11211.68138000053 | 64 | +| vllm | 2 | 4 | 4096 | 4096 | TTFT_SLO_EXCEEDED | None | 64 | 8406.252728727331 | 64 | +| vllm | 2 | 4 | 8192 | 128 | TTFT_SLO_BACKOFF_FOUND | None | 16 | 22475.134272625077 | 8 | +| vllm | 2 | 4 | 8192 | 256 | TTFT_SLO_EXCEEDED | None | 32 | 22539.211705624853 | 32 | +| vllm | 2 | 4 | 8192 | 512 | TTFT_SLO_EXCEEDED | None | 48 | 18690.72143294463 | 48 | +| vllm | 2 | 4 | 8192 | 1024 | TTFT_SLO_EXCEEDED | None | 32 | 17720.008987633595 | 64 | +| vllm | 2 | 4 | 8192 | 2048 | TTFT_SLO_EXCEEDED | None | 32 | 9893.374561568064 | 32 | +| vllm | 2 | 4 | 8192 | 4096 | TTFT_SLO_EXCEEDED | None | 32 | 7752.108917909322 | 48 | +| vllm | 2 | 4 | 16384 | 128 | TTFT_SLO_BACKOFF_FOUND | None | 8 | 24865.616658934323 | 1 | +| vllm | 2 | 4 | 16384 | 256 | TTFT_SLO_BACKOFF_FOUND | None | 16 | 23012.01710741807 | 1 | +| vllm | 2 | 4 | 16384 | 512 | TTFT_SLO_BACKOFF_FOUND | None | 16 | 19442.486909391213 | 8 | +| vllm | 2 | 4 | 16384 | 1024 | TTFT_SLO_EXCEEDED | None | 16 | 17326.656171496328 | 32 | +| vllm | 2 | 4 | 16384 | 2048 | TTFT_SLO_EXCEEDED | None | 16 | 13951.617144820304 | 32 | +| vllm | 2 | 4 | 32768 | 128 | TTFT_SLO_BACKOFF_FOUND | None | 16 | 24027.01351446888 | 1 | +| vllm | 2 | 4 | 32768 | 256 | TTFT_SLO_BACKOFF_FOUND | None | 8 | 31754.471763504465 | 1 | +| vllm | 2 | 4 | 32768 | 512 | TTFT_SLO_BACKOFF_FOUND | None | 16 | 21601.934455438146 | 1 | +| vllm | 2 | 4 | 32768 | 1024 | TTFT_SLO_BACKOFF_FOUND | None | 8 | 16002.913115323085 | 1 | +| vllm | 2 | 4 | 32768 | 2048 | TTFT_SLO_BACKOFF_FOUND | None | 8 | 13118.917606193083 | 1 | +| vllm | 2 | 4 | 65536 | 128 | TTFT_SLO_EXCEEDED | None | 16 | 22082.39716918432 | 1 | +| vllm | 2 | 4 | 65536 | 256 | TTFT_SLO_EXCEEDED | None | 16 | 21391.62354069105 | 1 | +| vllm | 2 | 4 | 65536 | 512 | TTFT_SLO_EXCEEDED | None | 16 | 18380.036907849004 | 1 | +| vllm | 2 | 4 | 65536 | 1024 | TTFT_SLO_EXCEEDED | None | 16 | 15690.052427755394 | 1 | +| vllm | 2 | 4 | 131072 | 128 | TTFT_GROUP_SKIP_THRESHOLD | None | 16 | 19183.73328417493 | 1 | +| vllm | 4 | 2 | 1024 | 128 | TTFT_SLO_BACKOFF_FOUND | None | 16 | 3344.8590600064417 | 1 | +| vllm | 4 | 2 | 1024 | 256 | TTFT_SLO_EXCEEDED | None | 32 | 6548.10995313187 | 32 | +| vllm | 4 | 2 | 1024 | 512 | TTFT_SLO_BACKOFF_FOUND | None | 16 | 3752.4892505307353 | 8 | +| vllm | 4 | 2 | 1024 | 1024 | TTFT_SLO_EXCEEDED | None | 48 | 6282.932443000561 | 48 | +| vllm | 4 | 2 | 1024 | 2048 | TTFT_SLO_EXCEEDED | None | 144 | 10013.653613623694 | 144 | +| vllm | 4 | 2 | 1024 | 4096 | TTFT_SLO_EXCEEDED | None | 112 | 8005.974972196393 | 112 | +| vllm | 4 | 2 | 4096 | 128 | TTFT_SLO_EXCEEDED | None | 32 | 19178.900984274085 | 32 | +| vllm | 4 | 2 | 4096 | 256 | TTFT_SLO_EXCEEDED | None | 64 | 24635.58080407481 | 64 | +| vllm | 4 | 2 | 4096 | 512 | TTFT_SLO_EXCEEDED | None | 48 | 27810.19370932178 | 112 | +| vllm | 4 | 2 | 4096 | 1024 | TTFT_SLO_EXCEEDED | None | 80 | 17567.35396640895 | 80 | +| vllm | 4 | 2 | 4096 | 2048 | TTFT_SLO_EXCEEDED | None | 64 | 12739.402829165518 | 80 | +| vllm | 4 | 2 | 4096 | 4096 | TTFT_SLO_EXCEEDED | None | 32 | 4580.400381472649 | 32 | +| vllm | 4 | 2 | 8192 | 128 | TTFT_SLO_EXCEEDED | None | 32 | 39853.46551460155 | 32 | +| vllm | 4 | 2 | 8192 | 256 | TTFT_SLO_EXCEEDED | None | 32 | 42569.34108492768 | 48 | +| vllm | 4 | 2 | 8192 | 512 | TTFT_SLO_EXCEEDED | None | 48 | 39561.92047849611 | 64 | +| vllm | 4 | 2 | 8192 | 1024 | TTFT_SLO_EXCEEDED | None | 32 | 19481.210961119526 | 32 | +| vllm | 4 | 2 | 8192 | 2048 | TTFT_SLO_EXCEEDED | None | 48 | 14382.678920590475 | 64 | +| vllm | 4 | 2 | 8192 | 4096 | TTFT_SLO_BACKOFF_FOUND | None | 16 | 6412.76920954965 | 8 | +| vllm | 4 | 2 | 16384 | 128 | TTFT_SLO_BACKOFF_FOUND | None | 1 | 33408.61928165981 | 1 | +| vllm | 4 | 2 | 16384 | 256 | TTFT_SLO_BACKOFF_FOUND | None | 8 | 50503.577165846604 | 8 | +| vllm | 4 | 2 | 16384 | 512 | TTFT_SLO_BACKOFF_FOUND | None | 16 | 30999.559317019954 | 8 | +| vllm | 4 | 2 | 16384 | 1024 | TTFT_SLO_EXCEEDED | None | 16 | 32508.7078149849 | 32 | +| vllm | 4 | 2 | 16384 | 2048 | TTFT_SLO_EXCEEDED | None | 32 | 11633.976050505793 | 32 | +| vllm | 4 | 2 | 32768 | 128 | TTFT_SLO_BACKOFF_FOUND | None | 1 | 27287.043986532444 | 1 | +| vllm | 4 | 2 | 32768 | 256 | TTFT_SLO_BACKOFF_FOUND | None | 1 | 23358.28664193622 | 1 | +| vllm | 4 | 2 | 32768 | 512 | TTFT_SLO_BACKOFF_FOUND | None | 16 | 18569.10902612545 | 1 | +| vllm | 4 | 2 | 32768 | 1024 | TTFT_SLO_BACKOFF_FOUND | None | 16 | 14748.417896491363 | 1 | +| vllm | 4 | 2 | 32768 | 2048 | TTFT_SLO_BACKOFF_FOUND | None | 16 | 15083.518350142393 | 1 | +| vllm | 4 | 2 | 65536 | 128 | TTFT_SLO_EXCEEDED | None | 16 | 18097.595470378677 | 1 | +| vllm | 4 | 2 | 65536 | 256 | TTFT_SLO_EXCEEDED | None | 16 | 16346.160186620771 | 1 | +| vllm | 4 | 2 | 65536 | 512 | TTFT_SLO_EXCEEDED | None | 16 | 14751.439899006828 | 1 | +| vllm | 4 | 2 | 65536 | 1024 | TTFT_SLO_EXCEEDED | None | 16 | 14436.120234197522 | 1 | +| vllm | 4 | 2 | 131072 | 128 | TTFT_GROUP_SKIP_THRESHOLD | None | 8 | 14275.478163292184 | 1 | +| vllm | 8 | 1 | 1024 | 128 | TTFT_SLO_BACKOFF_FOUND | None | 8 | 10025.042822339861 | 8 | +| vllm | 8 | 1 | 1024 | 256 | TPS_PLATEAU | 80 | 64 | 15042.006973739983 | 96 | +| vllm | 8 | 1 | 1024 | 512 | TPS_PLATEAU | 96 | 80 | 14896.170124755301 | 112 | +| vllm | 8 | 1 | 1024 | 1024 | TTFT_SLO_EXCEEDED | None | 80 | 10780.359050625337 | 144 | +| vllm | 8 | 1 | 1024 | 2048 | TTFT_SLO_EXCEEDED | None | 80 | 9194.780039334513 | 112 | +| vllm | 8 | 1 | 1024 | 4096 | TTFT_SLO_EXCEEDED | None | 80 | 7765.878131868169 | 80 | +| vllm | 8 | 1 | 4096 | 128 | TTFT_SLO_EXCEEDED | None | 32 | 21699.142108086646 | 32 | +| vllm | 8 | 1 | 4096 | 256 | TTFT_SLO_EXCEEDED | None | 32 | 49644.3174513865 | 48 | +| vllm | 8 | 1 | 4096 | 512 | TTFT_SLO_EXCEEDED | None | 48 | 38130.12746922595 | 64 | +| vllm | 8 | 1 | 4096 | 1024 | TTFT_SLO_EXCEEDED | None | 48 | 24033.173597879653 | 112 | +| vllm | 8 | 1 | 4096 | 2048 | TTFT_SLO_EXCEEDED | None | 64 | 15168.19077602635 | 80 | +| vllm | 8 | 1 | 4096 | 4096 | TTFT_SLO_EXCEEDED | None | 64 | 9018.155940958604 | 64 | +| vllm | 8 | 1 | 8192 | 128 | TTFT_SLO_BACKOFF_FOUND | None | 8 | 69391.60199642887 | 8 | +| vllm | 8 | 1 | 8192 | 256 | TTFT_SLO_EXCEEDED | None | 16 | 68459.44175385153 | 32 | +| vllm | 8 | 1 | 8192 | 512 | TTFT_SLO_EXCEEDED | None | 32 | 62289.915380678285 | 48 | +| vllm | 8 | 1 | 8192 | 1024 | TPS_PLATEAU | 32 | 16 | 28391.32676070545 | 48 | +| vllm | 8 | 1 | 8192 | 2048 | TTFT_SLO_EXCEEDED | None | 32 | 14246.097125929868 | 48 | +| vllm | 8 | 1 | 8192 | 4096 | TTFT_SLO_BACKOFF_FOUND | None | 8 | 7416.610969707548 | 8 | +| vllm | 8 | 1 | 16384 | 128 | TTFT_SLO_BACKOFF_FOUND | None | 8 | 125755.33533321305 | 8 | +| vllm | 8 | 1 | 16384 | 256 | TTFT_SLO_EXCEEDED | None | 16 | 126697.87934479979 | 32 | +| vllm | 8 | 1 | 16384 | 512 | TTFT_SLO_BACKOFF_FOUND | None | 1 | 16309.943166217838 | 1 | +| vllm | 8 | 1 | 16384 | 1024 | TTFT_SLO_BACKOFF_FOUND | None | 8 | 37116.415047850554 | 8 | +| vllm | 8 | 1 | 16384 | 2048 | TTFT_SLO_EXCEEDED | None | 16 | 29677.263467656077 | 32 | +| vllm | 8 | 1 | 32768 | 128 | TTFT_SLO_BACKOFF_FOUND | None | 1 | 12427.10553270719 | 1 | +| vllm | 8 | 1 | 32768 | 256 | TTFT_SLO_BACKOFF_FOUND | None | 16 | 12690.02075088378 | 1 | +| vllm | 8 | 1 | 32768 | 512 | TTFT_SLO_BACKOFF_FOUND | None | 16 | 12403.994325300202 | 1 | +| vllm | 8 | 1 | 32768 | 1024 | TTFT_SLO_BACKOFF_FOUND | None | 16 | 11992.382352227098 | 1 | +| vllm | 8 | 1 | 32768 | 2048 | TTFT_SLO_BACKOFF_FOUND | None | 16 | 11182.526858785568 | 1 | +| vllm | 8 | 1 | 65536 | 128 | TTFT_SLO_EXCEEDED | None | 1 | 12338.828565909838 | 1 | +| vllm | 8 | 1 | 65536 | 256 | TTFT_SLO_EXCEEDED | None | 1 | 11878.682996559066 | 1 | +| vllm | 8 | 1 | 65536 | 512 | TTFT_SLO_EXCEEDED | None | 16 | 11638.508850323253 | 1 | +| vllm | 8 | 1 | 65536 | 1024 | TTFT_SLO_EXCEEDED | None | 16 | 11425.73278736242 | 1 | +| vllm | 8 | 1 | 131072 | 128 | TTFT_GROUP_SKIP_THRESHOLD | None | 1 | 10979.03040593456 | 1 | + +`Saturation C` is the first point in the final low-gain streak. `Best TPS C` is the tested point with the highest observed Total TPS. diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/run_manifest.json b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/run_manifest.json new file mode 100644 index 0000000..d83e733 --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/run_manifest.json @@ -0,0 +1,27 @@ +{ + "experiment": "dsv4_dspark_h20_vllm_tp_dp_matrix", + "engine": "vllm", + "run_id": "adaptive_20260718-050846", + "model": "/data1/hf_models/DeepSeek-V4-Flash-DSpark", + "hardware": "8x NVIDIA H20 96GB", + "matrix": "/data1/yy/sskj/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/matrix.json", + "dataset": "random", + "tokenize_prompt": false, + "random_range_ratio": 1.0, + "search": { + "start_concurrency": 16, + "max_concurrency": 512, + "multiplier": 2, + "initial_backoff_concurrencies": [ + 8, + 1 + ], + "num_prompts_multiplier": 5, + "min_tps_gain_pct": 2.0, + "plateau_patience": 2, + "warmup_max_requests": 0, + "ttft_slo_ms": 4000.0, + "enable_ttft_slo_stop": 1, + "ttft_group_skip_ms": 8000.0 + } +} diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/shapes.tsv b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/shapes.tsv new file mode 100644 index 0000000..e1f82e6 --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/adaptive_results/adaptive_20260718-050846/shapes.tsv @@ -0,0 +1,40 @@ +mark input_len output_len +Y 1024 128 +Y 1024 256 +Y 1024 512 +Y 1024 1024 +Y 1024 2048 +Y 1024 4096 +Y 4096 128 +Y 4096 256 +Y 4096 512 +Y 4096 1024 +Y 4096 2048 +Y 4096 4096 +Y 8192 128 +Y 8192 256 +Y 8192 512 +Y 8192 1024 +Y 8192 2048 +Y 8192 4096 +Y 16384 128 +Y 16384 256 +Y 16384 512 +Y 16384 1024 +Y 16384 2048 +Y 32768 128 +Y 32768 256 +Y 32768 512 +Y 32768 1024 +Y 32768 2048 +Y 65536 128 +Y 65536 256 +Y 65536 512 +Y 65536 1024 +Y 131072 128 +Y 131072 256 +Y 131072 512 +Y 262144 128 +Y 262144 256 +Y 524288 128 +Y 1048576 128 diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/compare.py b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/compare.py new file mode 100644 index 0000000..16eb5cc --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/compare.py @@ -0,0 +1,163 @@ +#!/usr/bin/env python3 +"""Cross TP×DP configuration comparison for dsv4_dspark_h20_vllm_tp_dp_matrix. + +Usage: + python3 compare.py --run-root results/ [--output comparison.md] +""" +import argparse +import json +import re +from collections import defaultdict +from pathlib import Path + + +def load_result(result_root: Path) -> dict: + path = result_root / "results.json" + with open(path, "r", encoding="utf-8") as f: + return json.load(f) + + +def slo_status(ttft_p95_ms: float, tpot_mean_ms: float, + ttft_limit_ms: float = 3000.0, tpot_limit_ms: float = 50.0) -> str: + ttft_ok = ttft_p95_ms < ttft_limit_ms + tpot_ok = tpot_mean_ms < tpot_limit_ms + if ttft_ok and tpot_ok: + return "PASS" + if ttft_ok or tpot_ok: + return "PARTIAL" + return "FAIL" + + +def gpu_memory_str(gpu: dict | None) -> str: + if not gpu: + return "-" + peak = gpu.get("peak_used_mb", 0) + total = gpu.get("memory_total_mb", 0) + if total: + return f"{peak:.0f}/{total:.0f} ({100*peak/total:.1f}%)" + return f"{peak:.0f}" + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--run-root", type=Path, required=True) + parser.add_argument("-o", "--output", type=Path, default=Path("comparison.md")) + parser.add_argument("--ttft-limit", type=float, default=3000.0) + parser.add_argument("--tpot-limit", type=float, default=50.0) + args = parser.parse_args() + + # Discover configurations: tp*_dp* directories. + configs = [] + for subdir in sorted(args.run_root.iterdir()): + if not subdir.is_dir(): + continue + name = subdir.name + if not (name.startswith("tp") and "_dp" in name): + continue + results_json = subdir / "results.json" + if not results_json.exists(): + continue + configs.append((name, load_result(subdir))) + + if not configs: + print(f"No tp*_dp* results found under {args.run_root}") + return + + model = configs[0][1].get("metadata", {}).get("model", "unknown") + hardware = configs[0][1].get("metadata", {}).get("hardware", "unknown") + + # Group by scenario name. + by_scenario: dict[str, dict[str, dict]] = defaultdict(dict) + skipped: dict[str, dict[str, str]] = defaultdict(dict) + for label, data in configs: + for s in data.get("scenarios", []): + key = s["name"] + if s.get("status") == "skipped_oom": + skipped[key][label] = s.get("note", "skipped") + else: + by_scenario[key][label] = s + + with open(args.output, "w", encoding="utf-8") as f: + f.write(f"# vLLM TP×DP matrix comparison ({hardware})\n\n") + f.write("## Summary\n\n") + f.write(f"- Model: `{model}`\n") + f.write(f"- Hardware: {hardware}\n") + f.write("- Backend: vLLM (Docker)\n") + f.write("- Benchmark client: `sglang.bench_serving`\n") + f.write(f"- SLO reference: TTFT P95 < {args.ttft_limit}ms, TPOT mean < {args.tpot_limit}ms\n\n") + + # Configuration overview. + f.write("### Configurations\n\n") + f.write("| Config | TP | DP | GPUs/replica | Notes |\n") + f.write("|---|---:|---:|---:|---|\n") + for label, data in configs: + cfg = data.get("config", {}) + tp = cfg.get("tp", "?") + dp = cfg.get("dp", "?") + f.write(f"| {label} | {tp} | {dp} | {tp} | server args recorded per ISL in results.json |\n") + f.write("\n") + + # Side-by-side table. + f.write("## Side-by-side results\n\n") + headers = [ + "Scenario", "ISL", "OSL", "Config", "Conc", "Req/s", "OutTok/s", + "TTFT P95(ms)", "TTFT P99(ms)", "TPOT Mean(ms)", "TPOT P95(ms)", + "TPOT P99(ms)", "E2E P99(ms)", "Peak GPU mem", "SLO" + ] + f.write("| " + " | ".join(headers) + " |\n") + f.write("|" + "|".join(["---"] * len(headers)) + "|\n") + + for scenario_name in sorted(by_scenario.keys(), key=lambda x: tuple(map(int, re.findall(r"\d+", x)))): + _, isl, osl = re.findall(r"\d+", scenario_name) + # cfg_part not used; just for readability. + for label, data in configs: + s = by_scenario[scenario_name].get(label) + if s is None: + if scenario_name in skipped and label in skipped[scenario_name]: + note = skipped[scenario_name][label] + f.write(f"| {scenario_name} | {isl} | {osl} | {label} | - | - | - | - | - | - | - | - | - | - | {note} |\n") + continue + cfg = s["config"] + m = s["metrics"] + status = slo_status(m["ttft_ms"]["p95"], m["tpot_ms"]["mean"], args.ttft_limit, args.tpot_limit) + gpu = m.get("gpu_memory") + f.write( + f"| {scenario_name} | {isl} | {osl} | {label} | {cfg['concurrency']} | " + f"{m['request_throughput']:.2f} | {m['output_token_throughput']:.2f} | " + f"{m['ttft_ms']['p95']:.2f} | {m['ttft_ms']['p99']:.2f} | " + f"{m['tpot_ms']['mean']:.2f} | {m['tpot_ms']['p95']:.2f} | {m['tpot_ms']['p99']:.2f} | " + f"{m['e2e_ms']['p99']:.2f} | {gpu_memory_str(gpu)} | {status} |\n" + ) + + # Best throughput per ISL/OSL. + f.write("\n## Best throughput per (ISL, OSL)\n\n") + f.write("| ISL | OSL | Best Config | Concurrency | OutTok/s | TTFT P95(ms) | TPOT Mean(ms) | SLO |\n") + f.write("|---:|---:|---|---:|---:|---:|---:|---:|\n") + best_by_shape: dict[tuple[int, int], tuple[float, str, dict]] = {} + for scenario_name, backends in by_scenario.items(): + _, isl, osl = re.findall(r"\d+", scenario_name) + isl_i, osl_i = int(isl), int(osl) + for label, s in backends.items(): + m = s["metrics"] + out_tok = m["output_token_throughput"] + if (isl_i, osl_i) not in best_by_shape or out_tok > best_by_shape[(isl_i, osl_i)][0]: + best_by_shape[(isl_i, osl_i)] = (out_tok, label, s) + for (isl_i, osl_i), (out_tok, label, s) in sorted(best_by_shape.items()): + m = s["metrics"] + status = slo_status(m["ttft_ms"]["p95"], m["tpot_ms"]["mean"], args.ttft_limit, args.tpot_limit) + f.write( + f"| {isl_i} | {osl_i} | {label} | {s['config']['concurrency']} | " + f"{out_tok:.2f} | {m['ttft_ms']['p95']:.2f} | {m['tpot_ms']['mean']:.2f} | {status} |\n" + ) + + f.write("\n## Notes\n\n") + f.write("- SLO check uses TTFT P95 and TPOT mean.\n") + f.write("- A PARTIAL indicates one of the two metrics is out of target; FAIL indicates both are out.\n") + f.write("- `Peak GPU mem` shows peak used / total MB and utilization percentage.\n") + f.write("- Optional (P) combinations that failed are marked as skipped/OOM and do not break the run.\n") + + print(f"Wrote comparison to {args.output}") + + +if __name__ == "__main__": + main() diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/config.env b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/config.env new file mode 100644 index 0000000..3477a0c --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/config.env @@ -0,0 +1,93 @@ +# TP×DP matrix experiment for DeepSeek-V4-Flash-DSpark on H20 (8 GPUs) using vLLM. +# Tests vLLM with three parallel configurations: +# TP=2, DP=4 -> 2 GPUs per replica, 4 replicas +# TP=4, DP=2 -> 4 GPUs per replica, 2 replicas +# TP=8, DP=1 -> 8 GPUs, no data parallelism + +EXPERIMENT="dsv4_dspark_h20_vllm_tp_dp_matrix" +MODEL_NAME="DeepSeek-V4-Flash-DSpark" +MODEL_PATH="/data1/hf_models/DeepSeek-V4-Flash-DSpark" +SERVED_MODEL_NAME="deepseek-v4-flash-dspark" + +VLLM_PORT="${VLLM_PORT:-30032}" + +# Python interpreter for orchestration scripts (parse_backend.py, compare.py, etc.) +# and the benchmark client. Defaults to the system python3 if the sglang venv +# does not exist on the host. +VENV_CLIENT="${VENV_CLIENT:-/data1/yy/sskj/envs/sglang}" + +# Run the benchmark client natively (0) or inside Docker (1). +USE_DOCKER_CLIENT="${USE_DOCKER_CLIENT:-1}" + +export CUDA_VISIBLE_DEVICES="${CUDA_VISIBLE_DEVICES:-0,1,2,3,4,5,6,7}" + +# Runtime working directory for logs, pid files, and tmp. Defaults to a local +# directory under this experiment so the benchmark is self-contained. +RUNTIME_BASE="${RUNTIME_BASE:-${SCRIPT_DIR}/runtime}" + +# Parallel configurations to test. Format: "TP DP" +declare -a PARALLEL_CONFIGS=( + "2 4" + "4 2" + "8 1" +) + +# vLLM server settings +MAX_MODEL_LEN="${MAX_MODEL_LEN:-1048576}" +MAX_NUM_SEQS="${MAX_NUM_SEQS:-128}" +GPU_MEMORY_UTILIZATION="${GPU_MEMORY_UTILIZATION:-0.9}" +KV_CACHE_DTYPE="${KV_CACHE_DTYPE:-fp8}" +BLOCK_SIZE="${BLOCK_SIZE:-256}" + +# DSpark speculative decoding settings (requires a vLLM build with dspark +# support, e.g. the vllm-dspark env or a custom DOCKER_IMAGE). +SPEC_METHOD="${SPEC_METHOD:-dspark}" +SPEC_TOKENS="${SPEC_TOKENS:-5}" +TOKENIZER_MODE="${TOKENIZER_MODE:-deepseek_v4}" +REASONING_PARSER="${REASONING_PARSER:-deepseek_v4}" + +# Deployment switch. 0 = native vllm venv, 1 = Docker. +USE_DOCKER="${USE_DOCKER:-1}" +DOCKER_IMAGE="${DOCKER_IMAGE:-vllm/vllm-openai:latest}" + +# Engine readiness timeout inside the server (seconds). The DSpark draft model +# compiles ~140 TileLang kernels plus CUDA graphs on first start, which far +# exceeds vLLM's 600s default (VLLM_ENGINE_READY_TIMEOUT_S). 3600s gives +# enough headroom for a cold cache. +VLLM_ENGINE_READY_TIMEOUT_S="${VLLM_ENGINE_READY_TIMEOUT_S:-3600}" + +# Health-check retries in the start scripts (5s interval per retry). +# 720 * 5s = 60min, matching VLLM_ENGINE_READY_TIMEOUT_S above. +HEALTH_CHECK_RETRIES="${HEALTH_CHECK_RETRIES:-720}" + +# Benchmark client Docker image. vLLM's image does not include sglang.bench_serving, +# so the client runs inside the SGLang image and targets the vLLM backend via the +# OpenAI-compatible API. +DOCKER_CLIENT_IMAGE="${DOCKER_CLIENT_IMAGE:-lmsysorg/sglang:latest}" + +# Dataset used by sglang.bench_serving --dataset-name random. +# The random sampler needs a ShareGPT-style JSON file locally; it falls back to +# downloading from HuggingFace, which usually fails on offline H20 nodes. +DATASET_PATH="${DATASET_PATH:-/data1/yy/sskj/datasets/ShareGPT_V3_unfiltered_cleaned_split.json}" + +# Matrix and concurrency rules are defined in matrix.json by default. +MATRIX_FILE="${MATRIX_FILE:-${SCRIPT_DIR:-.}/matrix.json}" +MATRIX_MODE="${MATRIX_MODE:-Y}" + +# Sampling density for concurrency. +# 0 = use the default heuristic in generate_scenarios.py (6-8 points). +# 2 = only test the low and high endpoints. +export CONCURRENCY_SAMPLES="${CONCURRENCY_SAMPLES:-2}" + +# Per-scenario timeout to avoid hangs (seconds). +SCENARIO_TIMEOUT_S="${SCENARIO_TIMEOUT_S:-1800}" + +# GPU memory sampling interval (seconds). +GPU_MEM_SAMPLE_INTERVAL_S="${GPU_MEM_SAMPLE_INTERVAL_S:-1}" + +# Dry-run mode: if 1, only log the server args and scenario plan without starting +# any server or sending requests. +DRY_RUN="${DRY_RUN:-0}" + +# Per-config scenario limit for quick smoke tests. 0 = run all generated scenarios. +GRID_LIMIT="${GRID_LIMIT:-0}" diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/generate_scenarios.py b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/generate_scenarios.py new file mode 100644 index 0000000..2bfb152 --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/generate_scenarios.py @@ -0,0 +1,98 @@ +#!/usr/bin/env python3 +"""Generate the scenario list for the TP×DP matrix experiment. + +Reads matrix.json and prints TSV lines: + + mark input_len output_len concurrency num_prompts + +mark is one of Y/P/N. The caller (run_bench.sh) decides how to treat each. +""" +import argparse +import json +import math +import os +from pathlib import Path + + +def sample_concurrency(low: int, high: int, target: int) -> list[int]: + """Return only the low and high concurrency values in [low, high]. + + For the TP×DP matrix we only need the two endpoints of the concurrency + range (e.g. 1 and 128 for ISL=1024). The `target` argument is kept for + API compatibility but is ignored. + """ + assert 1 <= low <= high, f"invalid concurrency range: {low}-{high}" + if low == high: + return [low] + return [low, high] + + +def generate_scenarios(matrix_path: Path, mode: str, target_samples: int) -> list[dict]: + with open(matrix_path, "r", encoding="utf-8") as f: + data = json.load(f) + + matrix = data["matrix"] + concurrency_cfg = data["concurrency"] + + scenarios = [] + for isl_str in sorted(matrix.keys(), key=int): + osl_map = matrix[isl_str] + low = concurrency_cfg[isl_str]["low"] + high = concurrency_cfg[isl_str]["high"] + concurrencies = sample_concurrency(low, high, target_samples) + + for osl_str in sorted(osl_map.keys(), key=int): + mark = osl_map[osl_str] + if mode == "Y" and mark != "Y": + continue + if mode == "Y+P" and mark not in ("Y", "P"): + continue + # mode == "all" keeps everything, including N. + + for conc in concurrencies: + scenarios.append( + { + "mark": mark, + "input_len": int(isl_str), + "output_len": int(osl_str), + "concurrency": conc, + "num_prompts": conc * 5, + } + ) + + return scenarios + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--matrix", type=Path, default=Path("matrix.json")) + parser.add_argument("--mode", choices=["Y", "Y+P", "all"], default=None, + help="Scenario selection mode. Defaults to matrix.mode.") + parser.add_argument("--target-samples", type=int, default=0, + help="Target number of concurrency samples. 0 = heuristic (6-8).") + args = parser.parse_args() + + with open(args.matrix, "r", encoding="utf-8") as f: + data = json.load(f) + + mode = args.mode if args.mode else data.get("mode", "Y+P") + + target_samples = args.target_samples + if target_samples <= 0: + env_samples = os.getenv("CONCURRENCY_SAMPLES", "0") + try: + target_samples = int(env_samples) + except ValueError: + target_samples = 0 + if target_samples <= 0: + target_samples = 7 + + scenarios = generate_scenarios(args.matrix, mode, target_samples) + + print("mark\tinput_len\toutput_len\tconcurrency\tnum_prompts") + for s in scenarios: + print(f"{s['mark']}\t{s['input_len']}\t{s['output_len']}\t{s['concurrency']}\t{s['num_prompts']}") + + +if __name__ == "__main__": + main() diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/matrix.json b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/matrix.json new file mode 100644 index 0000000..dfc7572 --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/matrix.json @@ -0,0 +1,128 @@ +{ + "comment": "Only mandatory (Y) combinations are tested; 1M ISL is excluded per user request.", + "mode": "Y", + "matrix": { + "1024": { + "128": "Y", + "256": "Y", + "512": "Y", + "1024": "Y", + "2048": "Y", + "4096": "Y" + }, + "4096": { + "128": "Y", + "256": "Y", + "512": "Y", + "1024": "Y", + "2048": "Y", + "4096": "Y" + }, + "8192": { + "128": "Y", + "256": "Y", + "512": "Y", + "1024": "Y", + "2048": "Y", + "4096": "Y" + }, + "16384": { + "128": "Y", + "256": "Y", + "512": "Y", + "1024": "Y", + "2048": "Y", + "4096": "P" + }, + "32768": { + "128": "Y", + "256": "Y", + "512": "Y", + "1024": "Y", + "2048": "Y", + "4096": "P" + }, + "65536": { + "128": "Y", + "256": "Y", + "512": "Y", + "1024": "Y", + "2048": "P", + "4096": "N" + }, + "131072": { + "128": "Y", + "256": "Y", + "512": "Y", + "1024": "P", + "2048": "N", + "4096": "N" + }, + "262144": { + "128": "Y", + "256": "Y", + "512": "P", + "1024": "N", + "2048": "N", + "4096": "N" + }, + "524288": { + "128": "Y", + "256": "P", + "512": "N", + "1024": "N", + "2048": "N", + "4096": "N" + }, + "1048576": { + "128": "Y", + "256": "P", + "512": "N", + "1024": "N", + "2048": "N", + "4096": "N" + } + }, + "concurrency": { + "1024": { + "low": 1, + "high": 128 + }, + "4096": { + "low": 1, + "high": 64 + }, + "8192": { + "low": 1, + "high": 64 + }, + "16384": { + "low": 1, + "high": 32 + }, + "32768": { + "low": 1, + "high": 16 + }, + "65536": { + "low": 1, + "high": 8 + }, + "131072": { + "low": 1, + "high": 4 + }, + "262144": { + "low": 1, + "high": 2 + }, + "524288": { + "low": 1, + "high": 2 + }, + "1048576": { + "low": 1, + "high": 2 + } + } +} diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/run_adaptive_concurrency.sh b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/run_adaptive_concurrency.sh new file mode 100755 index 0000000..3e16cfe --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/run_adaptive_concurrency.sh @@ -0,0 +1,171 @@ +#!/usr/bin/env bash +# Find the Total-TPS saturation concurrency for each vLLM TP/DP/ISL/OSL shape. +set -Eeuo pipefail + +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +EXPERIMENT_NAME="$(basename "$SCRIPT_DIR")" + +# shellcheck source=/dev/null +source "${SCRIPT_DIR}/../../../scripts/common/lib.sh" +# shellcheck source=/dev/null +source "${SCRIPT_DIR}/../../../scripts/common/platform.sh" +# shellcheck source=/dev/null +source "${SCRIPT_DIR}/config.env" +# shellcheck source=/dev/null +source "${SCRIPT_DIR}/adaptive_config.env" +# shellcheck source=/dev/null +source "${SCRIPT_DIR}/../../../scripts/common/adaptive_bench_lib.sh" + +ENGINE="vllm" +ENGINE_PORT="$VLLM_PORT" +RESULT_BASE="${RESULT_BASE:-${SCRIPT_DIR}/adaptive_results}" +ACTIVE_ENGINE_SERVER_LOG="" + +if [[ -x "${VENV_CLIENT}/bin/python" ]]; then + PYTHON="${VENV_CLIENT}/bin/python" +else + PYTHON="$(command -v python3)" +fi + +DOCKER_IMAGE="${DOCKER_IMAGE:-vllm/vllm-openai:latest}" +DOCKER_CLIENT_IMAGE="${DOCKER_CLIENT_IMAGE:-lmsysorg/sglang:latest}" + +engine_is_healthy() { + curl --fail --silent --show-error --max-time 5 \ + "http://127.0.0.1:${ENGINE_PORT}/health" >/dev/null 2>&1 +} + +engine_stop_server() { + local tp="$1" + local dp="$2" + local pid_file="${RUNTIME_BASE}/${EXPERIMENT}_vllm_tp${tp}_dp${dp}.pid" + + if [[ -f "$pid_file" ]]; then + local pid + pid="$(cat "$pid_file")" + if kill -0 "$pid" 2>/dev/null; then + log "stopping vllm server pid=${pid} tp=${tp} dp=${dp}" + kill "$pid" 2>/dev/null || true + sleep 5 + kill -9 "$pid" 2>/dev/null || true + fi + rm -f "$pid_file" + fi + docker rm -f "${EXPERIMENT}_vllm_tp${tp}_dp${dp}" >/dev/null 2>&1 || true + ACTIVE_ENGINE_SERVER_LOG="" + sleep 2 +} + +engine_build_server_args() { + local tp="$1" + local dp="$2" + local -a args=( + vllm serve "$MODEL_PATH" + --trust-remote-code + --kv-cache-dtype "$KV_CACHE_DTYPE" + --block-size "$BLOCK_SIZE" + --tensor-parallel-size "$tp" + --gpu-memory-utilization "$GPU_MEMORY_UTILIZATION" + --max-model-len "$MAX_MODEL_LEN" + --max-num-seqs "$MAX_NUM_SEQS" + --no-enable-flashinfer-autotune + --tokenizer-mode "$TOKENIZER_MODE" + --reasoning-parser "$REASONING_PARSER" + --spec-method "$SPEC_METHOD" + --spec-model "$MODEL_PATH" + --spec-tokens "$SPEC_TOKENS" + --no-disable-hybrid-kv-cache-manager + --disable-uvicorn-access-log + --host 0.0.0.0 + --port "$ENGINE_PORT" + ) + if (( dp > 1 )); then + args+=(--data-parallel-size "$dp") + fi + printf '%q ' "${args[@]}" +} + +engine_start_server() { + local tp="$1" + local dp="$2" + local outer_log="${ADAPTIVE_LOG_DIR}/vllm_tp${tp}_dp${dp}.server.outer.log" + log "starting vllm server tp=${tp} dp=${dp}" + bash "${SCRIPT_DIR}/start_vllm_dp.sh" "$tp" "$dp" >> "$outer_log" 2>&1 + if ! engine_is_healthy; then + log "ERROR: vllm health check failed tp=${tp} dp=${dp}" + return 1 + fi + ACTIVE_ENGINE_SERVER_LOG="$( + find "${RUNTIME_BASE}/logs" -maxdepth 1 -type f \ + -name "${EXPERIMENT}_vllm*tp${tp}_dp${dp}_*.log" \ + -printf '%T@ %p\n' 2>/dev/null | sort -nr | head -n 1 | cut -d' ' -f2- + )" + log "vllm server healthy tp=${tp} dp=${dp} log=${ACTIVE_ENGINE_SERVER_LOG:-unknown}" +} + +engine_detect_oom() { + local detail_log="$1" + local tp="$2" + local dp="$3" + local pattern='CUDA out of memory|torch\.OutOfMemoryError|OutOfMemory|out of memory|OOM|RESOURCE_EXHAUSTED|Failed to allocate memory' + local outer_log="${ADAPTIVE_LOG_DIR}/vllm_tp${tp}_dp${dp}.server.outer.log" + local -a logs=("$detail_log" "$outer_log") + if [[ -n "$ACTIVE_ENGINE_SERVER_LOG" ]]; then + logs+=("$ACTIVE_ENGINE_SERVER_LOG") + fi + grep -Eiq "$pattern" "${logs[@]}" 2>/dev/null +} + +engine_run_bench() { + local isl="$1" + local osl="$2" + local concurrency="$3" + local num_prompts="$4" + local output_file="$5" + local warmup_requests + warmup_requests="$(adaptive_warmup_request_count "$concurrency")" + local -a bench_args=( + --backend vllm + --host 127.0.0.1 + --port "$ENGINE_PORT" + --dataset-name "$BENCH_DATASET_NAME" + --random-input-len "$isl" + --random-output-len "$osl" + --random-range-ratio "$RANDOM_RANGE_RATIO" + --num-prompts "$num_prompts" + --max-concurrency "$concurrency" + --request-rate 10000 + --warmup-requests "$warmup_requests" + --output-file "$output_file" + --output-details + --disable-tqdm + ) + if [[ "$BENCH_DATASET_NAME" == "random" ]]; then + bench_args+=(--dataset-path "$DATASET_PATH") + else + bench_args+=(--tokenize-prompt) + fi + + if [[ "$USE_DOCKER_CLIENT" == "1" ]]; then + local -a volume_args=(-v "${MODEL_PATH}:${MODEL_PATH}:ro" -v "${RESULT_BASE}:${RESULT_BASE}") + if [[ "$BENCH_DATASET_NAME" == "random" ]]; then + volume_args+=(-v "${DATASET_PATH}:${DATASET_PATH}:ro") + fi + docker run --rm \ + --network host \ + "${volume_args[@]}" \ + -e PYTHONUNBUFFERED=1 \ + -e HF_HUB_OFFLINE=1 \ + -e TRANSFORMERS_OFFLINE=1 \ + "$DOCKER_CLIENT_IMAGE" \ + python -m sglang.bench_serving "${bench_args[@]}" + else + "$PYTHON" -m sglang.bench_serving "${bench_args[@]}" + fi +} + +export -f engine_run_bench +export ENGINE_PORT MODEL_PATH RESULT_BASE DOCKER_CLIENT_IMAGE USE_DOCKER_CLIENT +export BENCH_DATASET_NAME DATASET_PATH RANDOM_RANGE_RATIO BENCH_WARMUP_MAX_REQUESTS PYTHON + +adaptive_main "$@" diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/run_adaptive_concurrency_add16.sh b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/run_adaptive_concurrency_add16.sh new file mode 100755 index 0000000..25fa919 --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/run_adaptive_concurrency_add16.sh @@ -0,0 +1,180 @@ +#!/usr/bin/env bash +# Find the Total-TPS saturation concurrency for each vLLM TP/DP/ISL/OSL shape. +set -Eeuo pipefail + +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +EXPERIMENT_NAME="$(basename "$SCRIPT_DIR")" + +# shellcheck source=/dev/null +source "${SCRIPT_DIR}/../../../scripts/common/lib.sh" +# shellcheck source=/dev/null +source "${SCRIPT_DIR}/../../../scripts/common/platform.sh" +# shellcheck source=/dev/null +source "${SCRIPT_DIR}/config.env" +# shellcheck source=/dev/null +source "${SCRIPT_DIR}/adaptive_config.env" +# shellcheck source=/dev/null +source "${SCRIPT_DIR}/../../../scripts/common/adaptive_bench_lib.sh" + +ENGINE="vllm" +ENGINE_PORT="$VLLM_PORT" +RESULT_BASE="${RESULT_BASE:-${SCRIPT_DIR}/adaptive_results}" +ACTIVE_ENGINE_SERVER_LOG="" + +if [[ -x "${VENV_CLIENT}/bin/python" ]]; then + PYTHON="${VENV_CLIENT}/bin/python" +else + PYTHON="$(command -v python3)" +fi + +DOCKER_IMAGE="${DOCKER_IMAGE:-vllm/vllm-openai:latest}" +DOCKER_CLIENT_IMAGE="${DOCKER_CLIENT_IMAGE:-lmsysorg/sglang:latest}" + +engine_is_healthy() { + curl --fail --silent --show-error --max-time 5 \ + "http://127.0.0.1:${ENGINE_PORT}/health" >/dev/null 2>&1 +} + +engine_stop_server() { + local tp="$1" + local dp="$2" + local pid_file="${RUNTIME_BASE}/${EXPERIMENT}_vllm_tp${tp}_dp${dp}.pid" + + if [[ -f "$pid_file" ]]; then + local pid + pid="$(cat "$pid_file")" + if kill -0 "$pid" 2>/dev/null; then + log "stopping vllm server pid=${pid} tp=${tp} dp=${dp}" + kill "$pid" 2>/dev/null || true + sleep 5 + kill -9 "$pid" 2>/dev/null || true + fi + rm -f "$pid_file" + fi + docker rm -f "${EXPERIMENT}_vllm_tp${tp}_dp${dp}" >/dev/null 2>&1 || true + ACTIVE_ENGINE_SERVER_LOG="" + sleep 2 +} + +engine_build_server_args() { + local tp="$1" + local dp="$2" + local -a args=( + vllm serve "$MODEL_PATH" + --trust-remote-code + --kv-cache-dtype "$KV_CACHE_DTYPE" + --block-size "$BLOCK_SIZE" + --tensor-parallel-size "$tp" + --gpu-memory-utilization "$GPU_MEMORY_UTILIZATION" + --max-model-len "$MAX_MODEL_LEN" + --max-num-seqs "$MAX_NUM_SEQS" + --no-enable-flashinfer-autotune + --tokenizer-mode "$TOKENIZER_MODE" + --reasoning-parser "$REASONING_PARSER" + --spec-method "$SPEC_METHOD" + --spec-model "$MODEL_PATH" + --spec-tokens "$SPEC_TOKENS" + --no-disable-hybrid-kv-cache-manager + --disable-uvicorn-access-log + --host 0.0.0.0 + --port "$ENGINE_PORT" + ) + if (( dp > 1 )); then + args+=(--data-parallel-size "$dp") + fi + printf '%q ' "${args[@]}" +} + +engine_start_server() { + local tp="$1" + local dp="$2" + local outer_log="${ADAPTIVE_LOG_DIR}/vllm_tp${tp}_dp${dp}.server.outer.log" + log "starting vllm server tp=${tp} dp=${dp}" + bash "${SCRIPT_DIR}/start_vllm_dp.sh" "$tp" "$dp" >> "$outer_log" 2>&1 + if ! engine_is_healthy; then + log "ERROR: vllm health check failed tp=${tp} dp=${dp}" + return 1 + fi + ACTIVE_ENGINE_SERVER_LOG="$( + find "${RUNTIME_BASE}/logs" -maxdepth 1 -type f \ + -name "${EXPERIMENT}_vllm*tp${tp}_dp${dp}_*.log" \ + -printf '%T@ %p\n' 2>/dev/null | sort -nr | head -n 1 | cut -d' ' -f2- + )" + log "vllm server healthy tp=${tp} dp=${dp} log=${ACTIVE_ENGINE_SERVER_LOG:-unknown}" +} + +engine_detect_oom() { + local detail_log="$1" + local tp="$2" + local dp="$3" + local pattern='CUDA out of memory|torch\.OutOfMemoryError|OutOfMemory|out of memory|OOM|RESOURCE_EXHAUSTED|Failed to allocate memory' + local outer_log="${ADAPTIVE_LOG_DIR}/vllm_tp${tp}_dp${dp}.server.outer.log" + local -a logs=("$detail_log" "$outer_log") + if [[ -n "$ACTIVE_ENGINE_SERVER_LOG" ]]; then + logs+=("$ACTIVE_ENGINE_SERVER_LOG") + fi + grep -Eiq "$pattern" "${logs[@]}" 2>/dev/null +} + +engine_run_bench() { + local isl="$1" + local osl="$2" + local concurrency="$3" + local num_prompts="$4" + local output_file="$5" + local warmup_requests + warmup_requests="$(adaptive_warmup_request_count "$concurrency")" + local -a bench_args=( + --backend vllm + --host 127.0.0.1 + --port "$ENGINE_PORT" + --dataset-name "$BENCH_DATASET_NAME" + --random-input-len "$isl" + --random-output-len "$osl" + --random-range-ratio "$RANDOM_RANGE_RATIO" + --num-prompts "$num_prompts" + --max-concurrency "$concurrency" + --request-rate 10000 + --warmup-requests "$warmup_requests" + --output-file "$output_file" + --output-details + --disable-tqdm + ) + if [[ "$BENCH_DATASET_NAME" == "random" ]]; then + bench_args+=(--dataset-path "$DATASET_PATH") + else + bench_args+=(--tokenize-prompt) + fi + + if [[ "$USE_DOCKER_CLIENT" == "1" ]]; then + local -a volume_args=(-v "${MODEL_PATH}:${MODEL_PATH}:ro" -v "${RESULT_BASE}:${RESULT_BASE}") + if [[ "$BENCH_DATASET_NAME" == "random" ]]; then + volume_args+=(-v "${DATASET_PATH}:${DATASET_PATH}:ro") + fi + docker run --rm \ + --network host \ + "${volume_args[@]}" \ + -e PYTHONUNBUFFERED=1 \ + -e HF_HUB_OFFLINE=1 \ + -e TRANSFORMERS_OFFLINE=1 \ + "$DOCKER_CLIENT_IMAGE" \ + python -m sglang.bench_serving "${bench_args[@]}" + else + "$PYTHON" -m sglang.bench_serving "${bench_args[@]}" + fi +} + +export -f engine_run_bench +export ENGINE_PORT MODEL_PATH RESULT_BASE DOCKER_CLIENT_IMAGE USE_DOCKER_CLIENT +export BENCH_DATASET_NAME DATASET_PATH RANDOM_RANGE_RATIO BENCH_WARMUP_MAX_REQUESTS PYTHON + +export SEARCH_START_CONCURRENCY=16 +export SEARCH_ADDEND=16 +# If the initial concurrency violates the TTFT SLO, search downward. Stop at +# the first acceptable value (16 -> 8; only try 1 when 8 still violates it). +export SEARCH_INITIAL_BACKOFF_CONCURRENCIES="8 1" +# When concurrency 1 still has a severely excessive TTFT, stop the remaining +# shapes in this TP/DP group. Zero disables this rule. +export TTFT_GROUP_SKIP_MS="${TTFT_GROUP_SKIP_MS:-8000}" + +adaptive_main "$@" diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/run_bench.sh b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/run_bench.sh new file mode 100755 index 0000000..e91d999 --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/run_bench.sh @@ -0,0 +1,555 @@ +#!/usr/bin/env bash +# TP×DP matrix benchmark for DeepSeek-V4-Flash-DSpark on vLLM (Docker). +set -Eeuo pipefail + +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +EXPERIMENT_NAME="$(basename "$SCRIPT_DIR")" + +# shellcheck source=/dev/null +source "${SCRIPT_DIR}/../../../scripts/common/lib.sh" +# shellcheck source=/dev/null +source "${SCRIPT_DIR}/../../../scripts/common/platform.sh" +# shellcheck source=/dev/null +source "${SCRIPT_DIR}/config.env" + +# Export variables used inside functions that are called via bash -c subshells. +export DATASET_PATH MODEL_PATH RESULT_BASE \ + DOCKER_IMAGE DOCKER_CLIENT_IMAGE USE_DOCKER_CLIENT + +RUN_ID="${RUN_ID:-$(date '+%Y%m%d-%H%M%S')}" +RESULT_BASE="${SCRIPT_DIR}/results" +MATRIX_FILE="${MATRIX_FILE:-${SCRIPT_DIR}/matrix.json}" +MATRIX_MODE="${MATRIX_MODE:-Y}" +SCENARIO_TIMEOUT_S="${SCENARIO_TIMEOUT_S:-1800}" +GPU_MEM_SAMPLE_INTERVAL_S="${GPU_MEM_SAMPLE_INTERVAL_S:-1}" +DRY_RUN="${DRY_RUN:-0}" +GRID_LIMIT="${GRID_LIMIT:-0}" + +if [[ -x "${VENV_CLIENT}/bin/python" ]]; then + PYTHON="${VENV_CLIENT}/bin/python" +else + PYTHON="$(command -v python3)" +fi + +DOCKER_IMAGE="${DOCKER_IMAGE:-vllm/vllm-openai:latest}" +DOCKER_CLIENT_IMAGE="${DOCKER_CLIENT_IMAGE:-lmsysorg/sglang:latest}" + +log_dir_global="${RESULT_BASE}/${RUN_ID}/logs" +mkdir -p "$log_dir_global" +log_init "${log_dir_global}/orchestrator.log" + +log "experiment=${EXPERIMENT_NAME} run_id=${RUN_ID} platform=${PLATFORM} hardware=${HARDWARE}" +log "matrix_mode=${MATRIX_MODE} matrix_file=${MATRIX_FILE} dry_run=${DRY_RUN} grid_limit=${GRID_LIMIT}" + +# --------------------------------------------------------------------------- +# Helpers +# --------------------------------------------------------------------------- + +is_server_healthy() { + curl --fail --silent --show-error --max-time 5 "http://127.0.0.1:${VLLM_PORT}/health" >/dev/null 2>&1 +} + +stop_server() { + local tp="$1" + local dp="$2" + + local pid_file="${RUNTIME_BASE}/${EXPERIMENT}_vllm_tp${tp}_dp${dp}.pid" + if [[ -f "$pid_file" ]]; then + local pid + pid="$(cat "$pid_file")" + if kill -0 "$pid" 2>/dev/null; then + log "stopping vllm server pid=${pid} (tp=${tp}, dp=${dp})" + kill "$pid" 2>/dev/null || true + sleep 5 + kill -9 "$pid" 2>/dev/null || true + fi + rm -f "$pid_file" + fi + + # Fallback: remove any Docker container started by this experiment. + docker rm -f "${EXPERIMENT}_vllm_tp${tp}_dp${dp}" >/dev/null 2>&1 || true + + # Fallback: kill any vllm serve processes for this model. + pkill -9 -f "vllm serve.*${MODEL_NAME}" 2>/dev/null || true + pkill -9 -f "vllm serve.*${MODEL_PATH}" 2>/dev/null || true + sleep 2 +} + +build_server_args() { + local tp="$1" + local dp="$2" + + local args=( + "vllm serve" "$MODEL_PATH" + --trust-remote-code + --kv-cache-dtype "$KV_CACHE_DTYPE" + --block-size "$BLOCK_SIZE" + --tensor-parallel-size "$tp" + --gpu-memory-utilization "$GPU_MEMORY_UTILIZATION" + --max-model-len "$MAX_MODEL_LEN" + --max-num-seqs "$MAX_NUM_SEQS" + --no-enable-flashinfer-autotune + --tokenizer-mode "$TOKENIZER_MODE" + --reasoning-parser "$REASONING_PARSER" + --spec-method "$SPEC_METHOD" + --spec-model "$MODEL_PATH" + --spec-tokens "$SPEC_TOKENS" + --no-disable-hybrid-kv-cache-manager + --disable-uvicorn-access-log + --host 0.0.0.0 + --port "$VLLM_PORT" + ) + if [[ "$dp" -gt 1 ]]; then + args+=( + --data-parallel-size "$dp" + ) + fi + printf '%s ' "${args[@]}" +} + +start_server() { + local tp="$1" + local dp="$2" + + log "starting vllm server tp=${tp} dp=${dp}" + bash "${SCRIPT_DIR}/start_vllm_dp.sh" "$tp" "$dp" \ + >> "${log_dir_global}/vllm_tp${tp}_dp${dp}.server.outer.log" 2>&1 + + if ! is_server_healthy; then + log "error: vllm server tp=${tp} dp=${dp} failed health check on port ${VLLM_PORT}" + return 1 + fi + log "vllm server tp=${tp} dp=${dp} is healthy on port ${VLLM_PORT}" +} + +restart_server() { + local tp="$1" + local dp="$2" + log "restarting vllm server tp=${tp} dp=${dp} after non-OOM failure" + stop_server "$tp" "$dp" + sleep 10 + start_server "$tp" "$dp" +} + +run_bench_serving() { + # Run sglang.bench_serving either natively or inside the SGLang Docker image. + if [[ "${USE_DOCKER_CLIENT:-1}" == "1" ]]; then + local vol_args=() + vol_args+=("-v" "${MODEL_PATH}:${MODEL_PATH}:ro") + if [[ -n "${DATASET_PATH:-}" && -f "${DATASET_PATH}" ]]; then + vol_args+=("-v" "${DATASET_PATH}:${DATASET_PATH}:ro") + fi + vol_args+=("-v" "${RESULT_BASE}:${RESULT_BASE}") + docker run --rm \ + --network host \ + "${vol_args[@]}" \ + -e PYTHONUNBUFFERED=1 \ + -e HF_HUB_OFFLINE=1 \ + -e TRANSFORMERS_OFFLINE=1 \ + -e HF_DATASETS_OFFLINE=1 \ + "${DOCKER_CLIENT_IMAGE}" \ + python -m sglang.bench_serving "$@" + else + "$PYTHON" -m sglang.bench_serving "$@" + fi +} +export -f run_bench_serving + +run_warmup() { + local input_len="$1" + local output_len="$2" + + log "warming up (input=${input_len}, output=${output_len}, num=1)" + bash -c ' + run_bench_serving \ + --backend vllm \ + --host 127.0.0.1 \ + --port "'"$VLLM_PORT"'" \ + --dataset-name random \ + --dataset-path "'"$DATASET_PATH"'" \ + --random-input-len "'"$input_len"'" \ + --random-output-len "'"$output_len"'" \ + --num-prompts 1 \ + --max-concurrency 1 \ + --request-rate 10000 \ + --output-file /dev/null \ + --output-details \ + >> "'"${log_dir_global}/warmup.log"'" 2>&1 + ' + log "warmup completed" +} + +scenario_already_completed() { + local output_file="$1" + local expected="$2" + [[ -s "$output_file" ]] || return 1 + local completed + completed="$("$PYTHON" -c " +import json, sys +path = sys.argv[1] +try: + with open(path, 'r', encoding='utf-8') as f: + for line in f: + line = line.strip() + if line: + data = json.loads(line) + print(data.get('completed', 0)) + break +except Exception: + print(0) +" "$output_file")" + [[ "${completed:-0}" -ge "$expected" ]] +} + +scenario_already_processed() { + local result_root="$1" + local scenario_name="$2" + local json_path="${result_root}/results.json" + [[ -f "$json_path" ]] || return 1 + "$PYTHON" -c " +import json, sys +path, name = sys.argv[1], sys.argv[2] +try: + with open(path, 'r', encoding='utf-8') as f: + data = json.load(f) + for s in data.get('scenarios', []): + if s.get('name') == name: + if s.get('status') or s.get('metrics', {}).get('success', 0) > 0: + sys.exit(0) +except Exception: + pass +sys.exit(1) +" "$json_path" "$scenario_name" +} + +detect_oom() { + local detail_log="$1" + local server_outer_log="$2" + local pattern='CUDA out of memory|torch\.OutOfMemoryError|OutOfMemory|out of memory|OOM|RESOURCE_EXHAUSTED|Failed to allocate memory' + if grep -Eiq "$pattern" "$detail_log" "$server_outer_log" 2>/dev/null; then + return 0 + fi + return 1 +} + +start_gpu_monitor() { + local csv_path="$1" + mkdir -p "$(dirname "$csv_path")" + nvidia-smi \ + --query-gpu=timestamp,index,memory.used,memory.total,utilization.gpu \ + --format=csv \ + -l "$GPU_MEM_SAMPLE_INTERVAL_S" \ + > "$csv_path" 2>/dev/null & + echo $! +} + +stop_gpu_monitor() { + local pid="$1" + if kill -0 "$pid" 2>/dev/null; then + kill "$pid" 2>/dev/null || true + sleep 1 + kill -9 "$pid" 2>/dev/null || true + fi +} + +append_scenario_record() { + local result_root="$1" + local json_path="$result_root/results.json" + shift + local scenario_json + scenario_json="$("$PYTHON" -c " +import json, sys +pairs = [a.split('=', 1) for a in sys.argv[1:]] +d = {} +for k, v in pairs: + try: + d[k] = json.loads(v) + except json.JSONDecodeError: + d[k] = v +print(json.dumps(d, ensure_ascii=False)) +" "$@")" + PYTHON="$PYTHON" append_scenario_to_json "$json_path" "$scenario_json" +} + +record_skipped_csv() { + local csv_path="$1" + shift + # Args: key=value + local row + row="$("$PYTHON" -c " +import csv, json, sys, io +pairs = [a.split('=', 1) for a in sys.argv[1:]] +d = {} +for k, v in pairs: + try: + d[k] = json.loads(v) + except json.JSONDecodeError: + d[k] = v +buf = io.StringIO() +writer = csv.DictWriter(buf, fieldnames=['engine','tp','dp','mark','isl','osl','concurrency','status','reason','detail_log'], extrasaction='ignore') +writer.writerow(d) +print(buf.getvalue().strip()) +" "$@")" + echo "$row" >> "$csv_path" +} + +skip_remaining_scenarios() { + local result_root="$1" + local scenario_tsv="$2" + local start_index="$3" + local status="$4" + local reason="$5" + local tp="$6" + local dp="$7" + local skipped_csv="${RESULT_BASE}/${RUN_ID}/skipped_after_oom.csv" + + local i=0 + tail -n +2 "$scenario_tsv" | while IFS=$'\t' read -r mark isl osl conc num; do + if (( i < start_index )); then + i=$((i + 1)) + continue + fi + i=$((i + 1)) + local sname="c${conc}_i${isl}_o${osl}" + if scenario_already_processed "$result_root" "$sname"; then + continue + fi + append_scenario_record "$result_root" \ + "name=${sname}" \ + "config=$(jq -n --arg phase main --argjson c "$conc" --argjson i "$isl" --argjson o "$osl" --arg dataset random --argjson n "$num" '{phase: $phase, concurrency: $c, input_len: $i, output_len: $o, dataset: $dataset, num_prompts: $n}')" \ + "status=\"${status}\"" \ + "note=\"${reason}\"" + record_skipped_csv "$skipped_csv" \ + "engine=vllm" "tp=${tp}" "dp=${dp}" "mark=${mark}" "isl=${isl}" "osl=${osl}" "concurrency=${conc}" "status=${status}" "reason=${reason}" + done +} + +# --------------------------------------------------------------------------- +# Per-configuration runner +# --------------------------------------------------------------------------- + +run_parallel_config() { + local tp="$1" + local dp="$2" + local config_label="tp${tp}_dp${dp}" + local result_root="${RESULT_BASE}/${RUN_ID}/${config_label}" + local raw_dir="${result_root}/raw_outputs" + local gpu_log_dir="${result_root}/gpu_logs" + local phase_log_dir="${result_root}/logs" + mkdir -p "$raw_dir" "$gpu_log_dir" "$phase_log_dir" + + log "===== ${config_label} START =====" + + # Generate scenario list for this config. + local scenario_tsv="${result_root}/scenarios.tsv" + "$PYTHON" "${SCRIPT_DIR}/generate_scenarios.py" \ + --matrix "$MATRIX_FILE" \ + --mode "$MATRIX_MODE" \ + > "$scenario_tsv" + local total_scenarios + total_scenarios="$(tail -n +2 "$scenario_tsv" | wc -l)" + log "generated ${total_scenarios} scenarios for ${config_label}" + + # Write metadata. + ensure_result_root "$result_root" + write_metadata_json \ + "${result_root}/results.json" \ + "${EXPERIMENT_NAME}_${config_label}" \ + "$RUN_ID" \ + "$MODEL_PATH" \ + "vllm" \ + "vllm" \ + "$HARDWARE" \ + "$ACCELERATOR" \ + "$CHIP" \ + "experiments/${EXPERIMENT_NAME}/run_bench.sh" \ + "$DOCKER_IMAGE" \ + "H20 vLLM TP×DP matrix for DeepSeek-V4-Flash-DSpark" + + local server_args_str + server_args_str="$(build_server_args "$tp" "$dp")" + jq --arg tp "$tp" --arg dp "$dp" --arg cuda "$CUDA_VISIBLE_DEVICES" --arg args "$server_args_str" \ + '.config = { + "tp": ($tp | tonumber), + "dp": ($dp | tonumber), + "cuda_visible_devices": $cuda, + "backend": "vllm", + "server_start_script": "experiments/'${EXPERIMENT_NAME}'/start_vllm_dp.sh", + "server_args": $args + }' "${result_root}/results.json" > "${result_root}/results.json.tmp" && \ + mv "${result_root}/results.json.tmp" "${result_root}/results.json" + + if [[ "$DRY_RUN" == "1" ]]; then + log "DRY_RUN: would start server with args: ${server_args_str}" + local line + tail -n +2 "$scenario_tsv" | while IFS=$'\t' read -r mark isl osl conc num; do + log "DRY_RUN: ${config_label} scenario mark=${mark} c=${conc} i=${isl} o=${osl} n=${num}" + done + log "===== ${config_label} DONE (dry run) =====" + return 0 + fi + + # Initialize skipped_after_oom.csv for this run. + local skipped_csv="${RESULT_BASE}/${RUN_ID}/skipped_after_oom.csv" + if [[ ! -f "$skipped_csv" ]]; then + echo "engine,tp,dp,mark,isl,osl,concurrency,status,reason,detail_log" > "$skipped_csv" + fi + + # Start server once for this TP×DP config. + if ! start_server "$tp" "$dp"; then + log "ERROR: ${config_label} failed to start; skipping all scenarios" + skip_remaining_scenarios "$result_root" "$scenario_tsv" 0 "SKIPPED_SERVICE_START_FAILED" "service failed to start" "$tp" "$dp" + log "===== ${config_label} DONE =====" + return 0 + fi + + # Warmup with a small prompt before the first scenario. + run_warmup 1024 128 || true + + # Read scenarios into an array so we can skip remaining entries on failure. + local -a scenarios=() + while IFS= read -r line; do + scenarios+=("$line") + done < <(tail -n +2 "$scenario_tsv") + + local i mark isl osl conc num + local output_file detail_log gpu_csv sname bench_rc + for (( i = 0; i < ${#scenarios[@]}; i++ )); do + IFS=$'\t' read -r mark isl osl conc num <<< "${scenarios[$i]}" + + if [[ "$GRID_LIMIT" -gt 0 && "$i" -ge "$GRID_LIMIT" ]]; then + log "GRID_LIMIT=${GRID_LIMIT} reached; skipping remaining scenarios" + skip_remaining_scenarios "$result_root" "$scenario_tsv" "$i" "SKIPPED_GRID_LIMIT" "GRID_LIMIT reached" "$tp" "$dp" + break + fi + + sname="c${conc}_i${isl}_o${osl}" + output_file="${raw_dir}/vllm_main_${conc}_${isl}_${osl}.jsonl" + detail_log="${phase_log_dir}/vllm_${config_label}_${sname}.log" + gpu_csv="${gpu_log_dir}/gpu_mem_${conc}_${isl}_${osl}.csv" + + if scenario_already_completed "$output_file" "$num" || scenario_already_processed "$result_root" "$sname"; then + log "skipping already-processed ${config_label} scenario: ${sname}" + continue + fi + + log "running ${config_label} scenario: mark=${mark} c=${conc} i=${isl} o=${osl} n=${num}" + + local gpu_pid + gpu_pid="$(start_gpu_monitor "$gpu_csv")" + + bench_rc=0 + timeout "$SCENARIO_TIMEOUT_S" bash -c ' + run_bench_serving \ + --backend vllm \ + --host 127.0.0.1 \ + --port "'"$VLLM_PORT"'" \ + --dataset-name random \ + --dataset-path "'"$DATASET_PATH"'" \ + --random-input-len "'"$isl"'" \ + --random-output-len "'"$osl"'" \ + --num-prompts "'"$num"'" \ + --max-concurrency "'"$conc"'" \ + --request-rate 10000 \ + --output-file "'"$output_file"'" \ + --output-details \ + > "'"$detail_log"'" 2>&1 + ' || bench_rc=$? + + stop_gpu_monitor "$gpu_pid" + + if [[ "$bench_rc" -eq 0 ]]; then + log "finished ${config_label} scenario: output=${output_file}" + append_scenario_record "$result_root" \ + "name=${sname}" \ + "config=$(jq -n --arg phase main --argjson c "$conc" --argjson i "$isl" --argjson o "$osl" --arg dataset random --argjson n "$num" '{phase: $phase, concurrency: $c, input_len: $i, output_len: $o, dataset: $dataset, num_prompts: $n}')" \ + "status=\"completed\"" \ + "note=\"benchmark finished successfully\"" + continue + fi + + # Failure handling. + if detect_oom "$detail_log" "${log_dir_global}/vllm_tp${tp}_dp${dp}.server.outer.log"; then + log "ERROR: ${config_label} scenario ${sname} triggered OOM; stopping config" + append_scenario_record "$result_root" \ + "name=${sname}" \ + "config=$(jq -n --arg phase main --argjson c "$conc" --argjson i "$isl" --argjson o "$osl" --arg dataset random --argjson n "$num" '{phase: $phase, concurrency: $c, input_len: $i, output_len: $o, dataset: $dataset, num_prompts: $n}')" \ + "status=\"OOM\"" \ + "note=\"detected CUDA out-of-memory\"" + record_skipped_csv "$skipped_csv" \ + "engine=vllm" "tp=${tp}" "dp=${dp}" "mark=${mark}" "isl=${isl}" "osl=${osl}" "concurrency=${conc}" "status=OOM" "reason=detected CUDA out-of-memory" "detail_log=${detail_log}" + stop_server "$tp" "$dp" + skip_remaining_scenarios "$result_root" "$scenario_tsv" "$((i + 1))" "SKIPPED_AFTER_OOM" "previous case OOM" "$tp" "$dp" + break + fi + + log "ERROR: ${config_label} scenario ${sname} failed (rc=${bench_rc}); see ${detail_log}" + if [[ "$mark" == "P" ]]; then + log "optional (P) scenario failed; recording as skipped and continuing" + append_scenario_record "$result_root" \ + "name=${sname}" \ + "config=$(jq -n --arg phase main --argjson c "$conc" --argjson i "$isl" --argjson o "$osl" --arg dataset random --argjson n "$num" '{phase: $phase, concurrency: $c, input_len: $i, output_len: $o, dataset: $dataset, num_prompts: $n}')" \ + "status=\"skipped_optional\"" \ + "note=\"optional scenario failed (rc=${bench_rc})\"" + record_skipped_csv "$skipped_csv" \ + "engine=vllm" "tp=${tp}" "dp=${dp}" "mark=${mark}" "isl=${isl}" "osl=${osl}" "concurrency=${conc}" "status=skipped_optional" "reason=optional scenario failed (rc=${bench_rc})" "detail_log=${detail_log}" + continue + fi + + # Mandatory scenario failed but not OOM: try to restart the server. + if restart_server "$tp" "$dp"; then + run_warmup 1024 128 || true + log "resuming ${config_label} after server restart" + continue + fi + + log "ERROR: ${config_label} server restart failed; skipping remaining scenarios" + append_scenario_record "$result_root" \ + "name=${sname}" \ + "config=$(jq -n --arg phase main --argjson c "$conc" --argjson i "$isl" --argjson o "$osl" --arg dataset random --argjson n "$num" '{phase: $phase, concurrency: $c, input_len: $i, output_len: $o, dataset: $dataset, num_prompts: $n}')" \ + "status=\"FAILED\"" \ + "note=\"scenario failed and server restart failed (rc=${bench_rc})\"" + record_skipped_csv "$skipped_csv" \ + "engine=vllm" "tp=${tp}" "dp=${dp}" "mark=${mark}" "isl=${isl}" "osl=${osl}" "concurrency=${conc}" "status=FAILED" "reason=scenario failed and server restart failed" "detail_log=${detail_log}" + skip_remaining_scenarios "$result_root" "$scenario_tsv" "$((i + 1))" "SKIPPED_RESTART_FAILED" "server restart failed" "$tp" "$dp" + break + done + + stop_server "$tp" "$dp" + + # Parse results. + log "parsing ${config_label} results" + "$PYTHON" "${SCRIPT_DIR}/../../../scripts/common/parse_backend.py" "$result_root" --backend vllm \ + >> "${phase_log_dir}/parse.log" 2>&1 || { + log "WARNING: parser failed for ${config_label}; see ${phase_log_dir}/parse.log" + } + + log "===== ${config_label} DONE =====" +} + +# --------------------------------------------------------------------------- +# Main +# --------------------------------------------------------------------------- + +# Cleanup any leftovers. +for cfg in "${PARALLEL_CONFIGS[@]}"; do + read -r tp dp <<< "$cfg" + stop_server "$tp" "$dp" +done + +# Run each parallel configuration. +for cfg in "${PARALLEL_CONFIGS[@]}"; do + read -r tp dp <<< "$cfg" + run_parallel_config "$tp" "$dp" +done + +# Generate cross-configuration comparison. +log "generating comparison report" +"$PYTHON" "${SCRIPT_DIR}/compare.py" \ + --run-root "${RESULT_BASE}/${RUN_ID}" \ + --output "${RESULT_BASE}/${RUN_ID}/comparison.md" \ + >> "${log_dir_global}/compare.log" 2>&1 || { + log "WARNING: comparison script failed; see ${log_dir_global}/compare.log" + } + +log "all results saved to ${RESULT_BASE}/${RUN_ID}" diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/0f368e85ad91dc38d1eca212e6350c2e26e5f453a6c404b9ceb10dca001fe742/device_kernel.cu b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/0f368e85ad91dc38d1eca212e6350c2e26e5f453a6c404b9ceb10dca001fe742/device_kernel.cu new file mode 100644 index 0000000..ce32651 --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/0f368e85ad91dc38d1eca212e6350c2e26e5f453a6c404b9ceb10dca001fe742/device_kernel.cu @@ -0,0 +1,424 @@ +#include +#include +#include +#include +#include +#include +#include +#ifdef ENABLE_BF16 +#include +#endif + +extern "C" __global__ void mhc_pre_big_fuse_with_norm_tilelang_kernel(float* comb_mix, const float* gemm_out_mul, const float* gemm_out_sqrsum, const float* hc_base, const float* hc_scale, bfloat16_t* layer_input, const bfloat16_t* norm_weight, float* post_mix, const bfloat16_t* residual, int num_tokens); +extern "C" __global__ void __launch_bounds__(96, 1) mhc_pre_big_fuse_with_norm_tilelang_kernel(float* comb_mix, const float* gemm_out_mul, const float* gemm_out_sqrsum, const float* hc_base, const float* hc_scale, bfloat16_t* layer_input, const bfloat16_t* norm_weight, float* post_mix, const bfloat16_t* residual, int num_tokens) { + extern __shared__ __align__(1024) uchar buf_dyn_shmem[]; + float mixes[1]; + float rms[1]; + float cm[1]; + float row_max[1]; + float row_sum[1]; + float col_sum[1]; + float sumsq_per_pos[16]; + float sumsq[1]; + float rsqrt_norm[1]; + float xl[64]; + float ol[16]; + bfloat16_t xs_local_cast[8]; + bfloat16_t xs_local_cast_1[8]; + bfloat16_t xs_local_cast_2[8]; + float w_local[16]; + float ol_1[16]; + bfloat16_t w_shared_local_cast_3[8]; + bfloat16_t output_shared_local_cast_4[8]; + bfloat16_t layer_input_local_cast_5[8]; + bfloat16_t w_shared_local_cast_6[8]; + bfloat16_t output_shared_local_cast_7[8]; + bfloat16_t layer_input_local_cast_8[8]; + bfloat16_t w_shared_local_cast_9[8]; + bfloat16_t output_shared_local_cast_10[8]; + bfloat16_t layer_input_local_cast_11[8]; + mixes[0] = 0x0p+0f/*0.000000e+00*/; + rms[0] = 0x0p+0f/*0.000000e+00*/; + cudaGridDependencySynchronize(); + for (int i_split = 0; i_split < 64; ++i_split) { + rms[0] = (rms[0] + gemm_out_sqrsum[((((int64_t)i_split) * ((int64_t)num_tokens)) + ((int64_t)((int)blockIdx.x)))]); + } + rms[0] = rsqrtf(((rms[0] / 0x1p+14f/*1.638400e+04*/) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + mixes[0] = 0x0p+0f/*0.000000e+00*/; + for (int i_split_1 = 0; i_split_1 < 64; ++i_split_1) { + mixes[0] = (mixes[0] + gemm_out_mul[(((((int64_t)((int)blockIdx.x)) * (int64_t)24) + ((((int64_t)i_split_1) * ((int64_t)num_tokens)) * (int64_t)24)) + (((int64_t)((int)threadIdx.x)) % (int64_t)24))]); + } + mixes[0] = (mixes[0] * rms[0]); + if ((((int)threadIdx.x) / 24) == 0) { + ((float*)buf_dyn_shmem)[(((int)threadIdx.x) % 24)] = mixes[0]; + } + __syncthreads(); + if (((int)threadIdx.x) < 32) { + if (((int)threadIdx.x) < 4) { + post_mix[((((int64_t)((int)blockIdx.x)) * (int64_t)4) + ((int64_t)((int)threadIdx.x)))] = ((0x1p+0f/*1.000000e+00*/ / (0x1p+0f/*1.000000e+00*/ + expf((0x0p+0f/*0.000000e+00*/ - ((((float*)buf_dyn_shmem)[(((int)threadIdx.x) + 4)] * hc_scale[1]) + hc_base[(((int)threadIdx.x) + 4)]))))) * 0x1p+1f/*2.000000e+00*/); + } + cm[0] = ((((float*)buf_dyn_shmem)[((((int)threadIdx.x) & 15) + 8)] * hc_scale[2]) + hc_base[((((int)threadIdx.x) & 15) + 8)]); + row_max[0] = -CUDART_INF_F; + row_max[0] = max(row_max[0], cm[0]); + row_max[0] = tl::AllReduce>::run(row_max[0]); + cm[0] = expf((cm[0] - row_max[0])); + row_sum[0] = 0x0p+0f/*0.000000e+00*/; + row_sum[0] = (row_sum[0] + cm[0]); + row_sum[0] = tl::AllReduce>::run(row_sum[0]); + cm[0] = ((cm[0] / row_sum[0]) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/); + col_sum[0] = 0x0p+0f/*0.000000e+00*/; + col_sum[0] = (col_sum[0] + cm[0]); + col_sum[0] = tl::AllReduce>::run(col_sum[0]); + cm[0] = (cm[0] / (col_sum[0] + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + for (int __1 = 0; __1 < 19; ++__1) { + row_sum[0] = 0x0p+0f/*0.000000e+00*/; + row_sum[0] = (row_sum[0] + cm[0]); + row_sum[0] = tl::AllReduce>::run(row_sum[0]); + cm[0] = (cm[0] / (row_sum[0] + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + col_sum[0] = 0x0p+0f/*0.000000e+00*/; + col_sum[0] = (col_sum[0] + cm[0]); + col_sum[0] = tl::AllReduce>::run(col_sum[0]); + cm[0] = (cm[0] / (col_sum[0] + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + } + if ((((int)threadIdx.x) >> 4) == 0) { + comb_mix[((((int64_t)((int)blockIdx.x)) * (int64_t)16) + (((int64_t)((int)threadIdx.x)) & (int64_t)15))] = cm[0]; + } + } else { + if (((int)threadIdx.x) < 36) { + ((float*)buf_dyn_shmem)[(((int)threadIdx.x) + 7224)] = ((0x1p+0f/*1.000000e+00*/ / (0x1p+0f/*1.000000e+00*/ + expf((0x0p+0f/*0.000000e+00*/ - ((((float*)buf_dyn_shmem)[(((int)threadIdx.x) - 32)] * hc_scale[0]) + hc_base[(((int)threadIdx.x) - 32)]))))) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/); + } + #pragma unroll + for (int i = 0; i < 4; ++i) { + float broadcast_var = 0x0p+0f/*0.000000e+00*/; + *(float4*)(sumsq_per_pos + (i * 4)) = make_float4(broadcast_var, broadcast_var, broadcast_var, broadcast_var); + } + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_1 = 0; i_1 < 8; ++i_1) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i_1 >> 1) * 1024) + (((((i_1 * 64) + ((int)threadIdx.x)) + 96) & 127) * 8)) + 48)])), (&(residual[(((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + ((((int64_t)i_1) >> (int64_t)1) * (int64_t)4096)) + (((((((int64_t)i_1) * (int64_t)64) + ((int64_t)((int)threadIdx.x))) + (int64_t)96) & (int64_t)127) * (int64_t)8))]))); + } + tl::cp_async_commit(); + #pragma unroll + for (int i_2 = 0; i_2 < 8; ++i_2) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i_2 >> 1) * 1024) + (((((i_2 * 64) + ((int)threadIdx.x)) + 96) & 127) * 8)) + 4144)])), (&(residual[((((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + ((((int64_t)i_2) >> (int64_t)1) * (int64_t)4096)) + (((((((int64_t)i_2) * (int64_t)64) + ((int64_t)((int)threadIdx.x))) + (int64_t)96) & (int64_t)127) * (int64_t)8)) + (int64_t)1024)]))); + } + tl::cp_async_commit(); + for (int i0_h = 0; i0_h < 2; ++i0_h) { + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_3 = 0; i_3 < 8; ++i_3) { + *(uint4*)(xs_local_cast + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + ((((i0_h * 4096) + (i_3 * 512)) + (((int)threadIdx.x) * 8)) - 208)); + for (int vec = 0; vec < 2; ++vec) { + float4 __2; + uint2 v_ = *(uint2*)(xs_local_cast + (vec * 4)); + ((float2*)(&__2))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v_))[0]); + ((float2*)(&__2))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v_))[1]); + *(float4*)(xl + ((i_3 * 8) + (vec * 4))) = __2; + } + } + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_4 = 0; i_4 < 8; ++i_4) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i0_h * 4096) + ((i_4 >> 1) * 1024)) + (((((i_4 * 64) + ((int)threadIdx.x)) + 96) & 127) * 8)) + 48)])), (&(residual[(((((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + ((((int64_t)i_4) >> (int64_t)1) * (int64_t)4096)) + (((int64_t)i0_h) * (int64_t)1024)) + (((((((int64_t)i_4) * (int64_t)64) + ((int64_t)((int)threadIdx.x))) + (int64_t)96) & (int64_t)127) * (int64_t)8)) + (int64_t)2048)]))); + } + tl::cp_async_commit(); + #pragma unroll + for (int i_5 = 0; i_5 < 4; ++i_5) { + float broadcast_var_1 = 0x0p+0f/*0.000000e+00*/; + *(float4*)(ol + (i_5 * 4)) = make_float4(broadcast_var_1, broadcast_var_1, broadcast_var_1, broadcast_var_1); + } + tl::__sync_thread_partial<3, 64>(); + for (int i_hc = 0; i_hc < 4; ++i_hc) { + float pre = ((float*)buf_dyn_shmem)[(i_hc + 7256)]; + #pragma unroll + for (int i_6 = 0; i_6 < 16; ++i_6) { + ol[i_6] = (ol[i_6] + (pre * xl[((i_hc * 16) + i_6)])); + } + } + #pragma unroll + for (int i_7 = 0; i_7 < 4; ++i_7) { + float4 __3; + float4 v__1 = *(float4*)(sumsq_per_pos + (i_7 * 4)); + float4 __4; + float4 v__2 = *(float4*)(ol + (i_7 * 4)); + __4.x = (v__2.x*v__2.x); + __4.y = (v__2.y*v__2.y); + __4.z = (v__2.z*v__2.z); + __4.w = (v__2.w*v__2.w); + __3.x = (v__1.x+__4.x); + __3.y = (v__1.y+__4.y); + __3.z = (v__1.z+__4.z); + __3.w = (v__1.w+__4.w); + *(float4*)(sumsq_per_pos + (i_7 * 4)) = __3; + uint2 __5; + float4 v__3 = *(float4*)(ol + (i_7 * 4)); + (reinterpret_cast<__nv_bfloat162*>(&__5))[0] = __float22bfloat162_rn(((float2*)(&v__3))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__5))[1] = __float22bfloat162_rn(((float2*)(&v__3))[1]); + *(uint2*)(((bfloat16_t*)buf_dyn_shmem) + (((((i0_h * 1024) + ((i_7 >> 1) * 512)) + (((int)threadIdx.x) * 8)) + ((i_7 & 1) * 4)) + 7984)) = __5; + } + } + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_8 = 0; i_8 < 8; ++i_8) { + *(uint4*)(xs_local_cast_1 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_8 * 512) + (((int)threadIdx.x) * 8)) - 208)); + for (int vec_1 = 0; vec_1 < 2; ++vec_1) { + float4 __6; + uint2 v__4 = *(uint2*)(xs_local_cast_1 + (vec_1 * 4)); + ((float2*)(&__6))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__4))[0]); + ((float2*)(&__6))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__4))[1]); + *(float4*)(xl + ((i_8 * 8) + (vec_1 * 4))) = __6; + } + } + #pragma unroll + for (int i_9 = 0; i_9 < 4; ++i_9) { + float broadcast_var_2 = 0x0p+0f/*0.000000e+00*/; + *(float4*)(ol + (i_9 * 4)) = make_float4(broadcast_var_2, broadcast_var_2, broadcast_var_2, broadcast_var_2); + } + for (int i_hc_1 = 0; i_hc_1 < 4; ++i_hc_1) { + float pre_1 = ((float*)buf_dyn_shmem)[(i_hc_1 + 7256)]; + #pragma unroll + for (int i_10 = 0; i_10 < 16; ++i_10) { + ol[i_10] = (ol[i_10] + (pre_1 * xl[((i_hc_1 * 16) + i_10)])); + } + } + #pragma unroll + for (int i_11 = 0; i_11 < 4; ++i_11) { + float4 __7; + float4 v__5 = *(float4*)(sumsq_per_pos + (i_11 * 4)); + float4 __8; + float4 v__6 = *(float4*)(ol + (i_11 * 4)); + __8.x = (v__6.x*v__6.x); + __8.y = (v__6.y*v__6.y); + __8.z = (v__6.z*v__6.z); + __8.w = (v__6.w*v__6.w); + __7.x = (v__5.x+__8.x); + __7.y = (v__5.y+__8.y); + __7.z = (v__5.z+__8.z); + __7.w = (v__5.w+__8.w); + *(float4*)(sumsq_per_pos + (i_11 * 4)) = __7; + uint2 __9; + float4 v__7 = *(float4*)(ol + (i_11 * 4)); + (reinterpret_cast<__nv_bfloat162*>(&__9))[0] = __float22bfloat162_rn(((float2*)(&v__7))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__9))[1] = __float22bfloat162_rn(((float2*)(&v__7))[1]); + *(uint2*)(((bfloat16_t*)buf_dyn_shmem) + (((((i_11 >> 1) * 512) + (((int)threadIdx.x) * 8)) + ((i_11 & 1) * 4)) + 10032)) = __9; + } + tl::cp_async_wait<0>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_12 = 0; i_12 < 8; ++i_12) { + *(uint4*)(xs_local_cast_2 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_12 * 512) + (((int)threadIdx.x) * 8)) + 3888)); + for (int vec_2 = 0; vec_2 < 2; ++vec_2) { + float4 __10; + uint2 v__8 = *(uint2*)(xs_local_cast_2 + (vec_2 * 4)); + ((float2*)(&__10))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__8))[0]); + ((float2*)(&__10))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__8))[1]); + *(float4*)(xl + ((i_12 * 8) + (vec_2 * 4))) = __10; + } + } + #pragma unroll + for (int i_13 = 0; i_13 < 4; ++i_13) { + float broadcast_var_3 = 0x0p+0f/*0.000000e+00*/; + *(float4*)(ol + (i_13 * 4)) = make_float4(broadcast_var_3, broadcast_var_3, broadcast_var_3, broadcast_var_3); + } + for (int i_hc_2 = 0; i_hc_2 < 4; ++i_hc_2) { + float pre_2 = ((float*)buf_dyn_shmem)[(i_hc_2 + 7256)]; + #pragma unroll + for (int i_14 = 0; i_14 < 16; ++i_14) { + ol[i_14] = (ol[i_14] + (pre_2 * xl[((i_hc_2 * 16) + i_14)])); + } + } + #pragma unroll + for (int i_15 = 0; i_15 < 4; ++i_15) { + float4 __11; + float4 v__9 = *(float4*)(sumsq_per_pos + (i_15 * 4)); + float4 __12; + float4 v__10 = *(float4*)(ol + (i_15 * 4)); + __12.x = (v__10.x*v__10.x); + __12.y = (v__10.y*v__10.y); + __12.z = (v__10.z*v__10.z); + __12.w = (v__10.w*v__10.w); + __11.x = (v__9.x+__12.x); + __11.y = (v__9.y+__12.y); + __11.z = (v__9.z+__12.z); + __11.w = (v__9.w+__12.w); + *(float4*)(sumsq_per_pos + (i_15 * 4)) = __11; + uint2 __13; + float4 v__11 = *(float4*)(ol + (i_15 * 4)); + (reinterpret_cast<__nv_bfloat162*>(&__13))[0] = __float22bfloat162_rn(((float2*)(&v__11))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__13))[1] = __float22bfloat162_rn(((float2*)(&v__11))[1]); + *(uint2*)(((bfloat16_t*)buf_dyn_shmem) + (((((i_15 >> 1) * 512) + (((int)threadIdx.x) * 8)) + ((i_15 & 1) * 4)) + 11056)) = __13; + } + sumsq[0] = 0x0p+0f/*0.000000e+00*/; + #pragma unroll + for (int rv = 0; rv < 16; ++rv) { + sumsq[0] = (sumsq[0] + sumsq_per_pos[(((rv & 1) * 8) + (rv >> 1))]); + } + tl::__sync_thread_partial<3, 64>(); + sumsq[0] = tl::AllReduce>::run(sumsq[0], (&(((float*)buf_dyn_shmem)[7192]))); + rsqrt_norm[0] = rsqrtf(((sumsq[0] / 0x1p+12f/*4.096000e+03*/) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + #pragma unroll + for (int i_16 = 0; i_16 < 2; ++i_16) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[(((i_16 * 512) + (((int)threadIdx.x) * 8)) + 12080)])), (&(norm_weight[(((i_16 * 512) + (((int)threadIdx.x) * 8)) - 256)]))); + } + tl::cp_async_commit(); + #pragma unroll + for (int i_17 = 0; i_17 < 2; ++i_17) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[(((i_17 * 512) + (((int)threadIdx.x) * 8)) + 13104)])), (&(norm_weight[(((i_17 * 512) + (((int)threadIdx.x) * 8)) + 768)]))); + } + tl::cp_async_commit(); + for (int i0_h_1 = 0; i0_h_1 < 2; ++i0_h_1) { + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_18 = 0; i_18 < 2; ++i_18) { + *(uint4*)(w_shared_local_cast_3 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + ((((i0_h_1 * 1024) + (i_18 * 512)) + (((int)threadIdx.x) * 8)) + 12080)); + for (int vec_3 = 0; vec_3 < 2; ++vec_3) { + float4 __14; + uint2 v__12 = *(uint2*)(w_shared_local_cast_3 + (vec_3 * 4)); + ((float2*)(&__14))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__12))[0]); + ((float2*)(&__14))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__12))[1]); + *(float4*)(w_local + ((i_18 * 8) + (vec_3 * 4))) = __14; + } + } + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_19 = 0; i_19 < 2; ++i_19) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i0_h_1 * 1024) + (i_19 * 512)) + (((int)threadIdx.x) * 8)) + 12080)])), (&(norm_weight[((((i0_h_1 * 1024) + (i_19 * 512)) + (((int)threadIdx.x) * 8)) + 1792)]))); + } + tl::cp_async_commit(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_20 = 0; i_20 < 2; ++i_20) { + *(uint4*)(output_shared_local_cast_4 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + ((((i0_h_1 * 1024) + (i_20 * 512)) + (((int)threadIdx.x) * 8)) + 7984)); + for (int vec_4 = 0; vec_4 < 2; ++vec_4) { + float4 __15; + float4 __16; + float4 __17; + uint2 v__13 = *(uint2*)(output_shared_local_cast_4 + (vec_4 * 4)); + ((float2*)(&__17))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__13))[0]); + ((float2*)(&__17))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__13))[1]); + float4 v__14 = make_float4(rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0]); + __16.x = (__17.x*v__14.x); + __16.y = (__17.y*v__14.y); + __16.z = (__17.z*v__14.z); + __16.w = (__17.w*v__14.w); + float4 v__15 = *(float4*)(w_local + ((i_20 * 8) + (vec_4 * 4))); + __15.x = (__16.x*v__15.x); + __15.y = (__16.y*v__15.y); + __15.z = (__16.z*v__15.z); + __15.w = (__16.w*v__15.w); + *(float4*)(ol_1 + ((i_20 * 8) + (vec_4 * 4))) = __15; + } + } + #pragma unroll + for (int i_21 = 0; i_21 < 2; ++i_21) { + for (int vec_5 = 0; vec_5 < 2; ++vec_5) { + uint2 __18; + float4 v__16 = *(float4*)(ol_1 + ((i_21 * 8) + (vec_5 * 4))); + (reinterpret_cast<__nv_bfloat162*>(&__18))[0] = __float22bfloat162_rn(((float2*)(&v__16))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__18))[1] = __float22bfloat162_rn(((float2*)(&v__16))[1]); + *(uint2*)(layer_input_local_cast_5 + (vec_5 * 4)) = __18; + } + *(uint4*)(layer_input + (((((((int64_t)((int)blockIdx.x)) * (int64_t)4096) + (((int64_t)i0_h_1) * (int64_t)1024)) + (((int64_t)i_21) * (int64_t)512)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8)) - (int64_t)256)) = *(uint4*)(layer_input_local_cast_5 + 0); + } + } + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_22 = 0; i_22 < 2; ++i_22) { + *(uint4*)(w_shared_local_cast_6 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_22 * 512) + (((int)threadIdx.x) * 8)) + 12080)); + for (int vec_6 = 0; vec_6 < 2; ++vec_6) { + float4 __19; + uint2 v__17 = *(uint2*)(w_shared_local_cast_6 + (vec_6 * 4)); + ((float2*)(&__19))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__17))[0]); + ((float2*)(&__19))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__17))[1]); + *(float4*)(w_local + ((i_22 * 8) + (vec_6 * 4))) = __19; + } + } + #pragma unroll + for (int i_23 = 0; i_23 < 2; ++i_23) { + *(uint4*)(output_shared_local_cast_7 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_23 * 512) + (((int)threadIdx.x) * 8)) + 10032)); + for (int vec_7 = 0; vec_7 < 2; ++vec_7) { + float4 __20; + float4 __21; + float4 __22; + uint2 v__18 = *(uint2*)(output_shared_local_cast_7 + (vec_7 * 4)); + ((float2*)(&__22))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__18))[0]); + ((float2*)(&__22))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__18))[1]); + float4 v__19 = make_float4(rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0]); + __21.x = (__22.x*v__19.x); + __21.y = (__22.y*v__19.y); + __21.z = (__22.z*v__19.z); + __21.w = (__22.w*v__19.w); + float4 v__20 = *(float4*)(w_local + ((i_23 * 8) + (vec_7 * 4))); + __20.x = (__21.x*v__20.x); + __20.y = (__21.y*v__20.y); + __20.z = (__21.z*v__20.z); + __20.w = (__21.w*v__20.w); + *(float4*)(ol_1 + ((i_23 * 8) + (vec_7 * 4))) = __20; + } + } + #pragma unroll + for (int i_24 = 0; i_24 < 2; ++i_24) { + for (int vec_8 = 0; vec_8 < 2; ++vec_8) { + uint2 __23; + float4 v__21 = *(float4*)(ol_1 + ((i_24 * 8) + (vec_8 * 4))); + (reinterpret_cast<__nv_bfloat162*>(&__23))[0] = __float22bfloat162_rn(((float2*)(&v__21))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__23))[1] = __float22bfloat162_rn(((float2*)(&v__21))[1]); + *(uint2*)(layer_input_local_cast_8 + (vec_8 * 4)) = __23; + } + *(uint4*)(layer_input + ((((((int64_t)((int)blockIdx.x)) * (int64_t)4096) + (((int64_t)i_24) * (int64_t)512)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8)) + (int64_t)1792)) = *(uint4*)(layer_input_local_cast_8 + 0); + } + tl::cp_async_wait<0>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_25 = 0; i_25 < 2; ++i_25) { + *(uint4*)(w_shared_local_cast_9 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_25 * 512) + (((int)threadIdx.x) * 8)) + 13104)); + for (int vec_9 = 0; vec_9 < 2; ++vec_9) { + float4 __24; + uint2 v__22 = *(uint2*)(w_shared_local_cast_9 + (vec_9 * 4)); + ((float2*)(&__24))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__22))[0]); + ((float2*)(&__24))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__22))[1]); + *(float4*)(w_local + ((i_25 * 8) + (vec_9 * 4))) = __24; + } + } + #pragma unroll + for (int i_26 = 0; i_26 < 2; ++i_26) { + *(uint4*)(output_shared_local_cast_10 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_26 * 512) + (((int)threadIdx.x) * 8)) + 11056)); + for (int vec_10 = 0; vec_10 < 2; ++vec_10) { + float4 __25; + float4 __26; + float4 __27; + uint2 v__23 = *(uint2*)(output_shared_local_cast_10 + (vec_10 * 4)); + ((float2*)(&__27))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__23))[0]); + ((float2*)(&__27))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__23))[1]); + float4 v__24 = make_float4(rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0]); + __26.x = (__27.x*v__24.x); + __26.y = (__27.y*v__24.y); + __26.z = (__27.z*v__24.z); + __26.w = (__27.w*v__24.w); + float4 v__25 = *(float4*)(w_local + ((i_26 * 8) + (vec_10 * 4))); + __25.x = (__26.x*v__25.x); + __25.y = (__26.y*v__25.y); + __25.z = (__26.z*v__25.z); + __25.w = (__26.w*v__25.w); + *(float4*)(ol_1 + ((i_26 * 8) + (vec_10 * 4))) = __25; + } + } + #pragma unroll + for (int i_27 = 0; i_27 < 2; ++i_27) { + for (int vec_11 = 0; vec_11 < 2; ++vec_11) { + uint2 __28; + float4 v__26 = *(float4*)(ol_1 + ((i_27 * 8) + (vec_11 * 4))); + (reinterpret_cast<__nv_bfloat162*>(&__28))[0] = __float22bfloat162_rn(((float2*)(&v__26))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__28))[1] = __float22bfloat162_rn(((float2*)(&v__26))[1]); + *(uint2*)(layer_input_local_cast_11 + (vec_11 * 4)) = __28; + } + *(uint4*)(layer_input + ((((((int64_t)((int)blockIdx.x)) * (int64_t)4096) + (((int64_t)i_27) * (int64_t)512)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8)) + (int64_t)2816)) = *(uint4*)(layer_input_local_cast_11 + 0); + } + } + cudaTriggerProgrammaticLaunchCompletion(); +} + diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/0f368e85ad91dc38d1eca212e6350c2e26e5f453a6c404b9ceb10dca001fe742/host_kernel.cu b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/0f368e85ad91dc38d1eca212e6350c2e26e5f453a6c404b9ceb10dca001fe742/host_kernel.cu new file mode 100644 index 0000000..230868b --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/0f368e85ad91dc38d1eca212e6350c2e26e5f453a6c404b9ceb10dca001fe742/host_kernel.cu @@ -0,0 +1,3359 @@ +// tilelang target: c -keys=cpu +#define TVM_EXPORTS +#include "tvm/runtime/base.h" +#include "tvm/runtime/c_backend_api.h" +#include "tvm/ffi/c_api.h" +#include +#include +#include +#ifdef __OBJC__ +#include "tvm/runtime/device_api.h" +#include "tvm/ffi/function.h" +#include +#include +#include +#endif +void* __tvm_ffi__library_ctx = NULL; +static void* __tvm_error_ndim_mismatch_packed = NULL; +static void* __tvm_error_dtype_mismatch_packed = NULL; +static void* __tvm_error_expect_eq_packed = NULL; +static void* __tvm_error_constraint_violation_packed = NULL; +static void* __tvm_error_byte_offset_mismatch_packed = NULL; +static void* __tvm_error_device_type_mismatch_packed = NULL; +static void* __tvm_error_null_ptr_packed = NULL; +static void* __tvm_set_device_packed = NULL; +static void* mhc_pre_big_fuse_with_norm_tilelang_kernel_packed = NULL; +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_mhc_pre_big_fuse_with_norm_tilelang(void* self_handle, void* args, int32_t num_args, void* result); +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_mhc_pre_big_fuse_with_norm_tilelang(void* self_handle, void* args, int32_t num_args, void* result) { + __attribute__((aligned(64))) TVMFFIAny stack[16]; + void* stack_ffi_any = stack; + if (!((num_args == 9))) { + char __tvm_assert_msg_buf[512]; + snprintf(__tvm_assert_msg_buf, 512, "%s; expected: %lld, got: %lld", "mhc_pre_big_fuse_with_norm_tilelang: num_args should be 9", (long long)(num_args), (long long)(9)); + TVMFFIErrorSetRaisedFromCStr("RuntimeError", __tvm_assert_msg_buf); + return -1; + } + if (!(!(args == NULL))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang: args pointer is NULL"); + return -1; + } + int32_t gemm_out_mul_type_index = (((TVMFFIAny*)args)[0].type_index); + if (!(((((gemm_out_mul_type_index == 0) || (gemm_out_mul_type_index == 4)) || (gemm_out_mul_type_index == 7)) || (64 <= gemm_out_mul_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input gemm_out_mul expected pointer or tensor handle"); + return -1; + } + int32_t gemm_out_sqrsum_type_index = (((TVMFFIAny*)args)[1].type_index); + if (!(((((gemm_out_sqrsum_type_index == 0) || (gemm_out_sqrsum_type_index == 4)) || (gemm_out_sqrsum_type_index == 7)) || (64 <= gemm_out_sqrsum_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input gemm_out_sqrsum expected pointer or tensor handle"); + return -1; + } + int32_t hc_scale_type_index = (((TVMFFIAny*)args)[2].type_index); + if (!(((((hc_scale_type_index == 0) || (hc_scale_type_index == 4)) || (hc_scale_type_index == 7)) || (64 <= hc_scale_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input hc_scale expected pointer or tensor handle"); + return -1; + } + int32_t hc_base_type_index = (((TVMFFIAny*)args)[3].type_index); + if (!(((((hc_base_type_index == 0) || (hc_base_type_index == 4)) || (hc_base_type_index == 7)) || (64 <= hc_base_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input hc_base expected pointer or tensor handle"); + return -1; + } + int32_t residual_type_index = (((TVMFFIAny*)args)[4].type_index); + if (!(((((residual_type_index == 0) || (residual_type_index == 4)) || (residual_type_index == 7)) || (64 <= residual_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input residual expected pointer or tensor handle"); + return -1; + } + int32_t post_mix_type_index = (((TVMFFIAny*)args)[5].type_index); + if (!(((((post_mix_type_index == 0) || (post_mix_type_index == 4)) || (post_mix_type_index == 7)) || (64 <= post_mix_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input post_mix expected pointer or tensor handle"); + return -1; + } + int32_t comb_mix_type_index = (((TVMFFIAny*)args)[6].type_index); + if (!(((((comb_mix_type_index == 0) || (comb_mix_type_index == 4)) || (comb_mix_type_index == 7)) || (64 <= comb_mix_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input comb_mix expected pointer or tensor handle"); + return -1; + } + int32_t layer_input_type_index = (((TVMFFIAny*)args)[7].type_index); + if (!(((((layer_input_type_index == 0) || (layer_input_type_index == 4)) || (layer_input_type_index == 7)) || (64 <= layer_input_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input layer_input expected pointer or tensor handle"); + return -1; + } + int32_t norm_weight_type_index = (((TVMFFIAny*)args)[8].type_index); + if (!(((((norm_weight_type_index == 0) || (norm_weight_type_index == 4)) || (norm_weight_type_index == 7)) || (64 <= norm_weight_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input norm_weight expected pointer or tensor handle"); + return -1; + } + void* gemm_out_mul = ((gemm_out_mul_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[0].v_ptr) + 24)) : (((TVMFFIAny*)args)[0].v_ptr)); + void* gemm_out_sqrsum = ((gemm_out_sqrsum_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[1].v_ptr) + 24)) : (((TVMFFIAny*)args)[1].v_ptr)); + void* hc_scale = ((hc_scale_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[2].v_ptr) + 24)) : (((TVMFFIAny*)args)[2].v_ptr)); + void* hc_base = ((hc_base_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[3].v_ptr) + 24)) : (((TVMFFIAny*)args)[3].v_ptr)); + void* residual = ((residual_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[4].v_ptr) + 24)) : (((TVMFFIAny*)args)[4].v_ptr)); + void* post_mix = ((post_mix_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[5].v_ptr) + 24)) : (((TVMFFIAny*)args)[5].v_ptr)); + void* comb_mix = ((comb_mix_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[6].v_ptr) + 24)) : (((TVMFFIAny*)args)[6].v_ptr)); + void* layer_input = ((layer_input_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[7].v_ptr) + 24)) : (((TVMFFIAny*)args)[7].v_ptr)); + void* norm_weight = ((norm_weight_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[8].v_ptr) + 24)) : (((TVMFFIAny*)args)[8].v_ptr)); + bool mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_is_null = (gemm_out_mul == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.gemm_out_mul is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_is_null = (gemm_out_sqrsum == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.gemm_out_sqrsum is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_hc_scale_is_null = (hc_scale == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_hc_scale_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.hc_scale is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_hc_base_is_null = (hc_base == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_hc_base_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.hc_base is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_residual_is_null = (residual == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_residual_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.residual is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_post_mix_is_null = (post_mix == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_post_mix_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.post_mix is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_comb_mix_is_null = (comb_mix == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_comb_mix_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.comb_mix is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_layer_input_is_null = (layer_input == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_layer_input_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.layer_input is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_norm_weight_is_null = (norm_weight == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_norm_weight_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.norm_weight is expected to have non-NULL pointer"); + return -1; + } + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape = (((DLTensor*)gemm_out_mul)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape = (((DLTensor*)gemm_out_sqrsum)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_hc_scale_shape = (((DLTensor*)hc_scale)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_hc_base_shape = (((DLTensor*)hc_base)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_residual_shape = (((DLTensor*)residual)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape = (((DLTensor*)post_mix)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape = (((DLTensor*)comb_mix)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape = (((DLTensor*)layer_input)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_norm_weight_shape = (((DLTensor*)norm_weight)[0].shape); + if ((((DLTensor*)gemm_out_mul)[0].ndim) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_1; + result_1.type_index = kTVMFFINone; + result_1.zero_padding = 0; + result_1.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_1) != 0) { + return -1; + } + } + if (!((bool)1)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "Symbolic shape variable num_tokens requires at least one non-null buffer among: mhc_pre_big_fuse_with_norm_tilelang.gemm_out_mul, mhc_pre_big_fuse_with_norm_tilelang.gemm_out_sqrsum, mhc_pre_big_fuse_with_norm_tilelang.residual, mhc_pre_big_fuse_with_norm_tilelang.post_mix, mhc_pre_big_fuse_with_norm_tilelang.comb_mix, mhc_pre_big_fuse_with_norm_tilelang.layer_input"); + return -1; + } + int32_t num_tokens = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]); + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides = (((DLTensor*)gemm_out_mul)[0].strides); + int32_t dev_id = (((DLTensor*)gemm_out_mul)[0].device.device_id); + void* gemm_out_mul_1 = (((DLTensor*)gemm_out_mul)[0].data); + if ((((DLTensor*)gemm_out_sqrsum)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_2; + result_2.type_index = kTVMFFINone; + result_2.zero_padding = 0; + result_2.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_2) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides = (((DLTensor*)gemm_out_sqrsum)[0].strides); + void* gemm_out_sqrsum_1 = (((DLTensor*)gemm_out_sqrsum)[0].data); + if ((((DLTensor*)hc_scale)[0].ndim) != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_3; + result_3.type_index = kTVMFFINone; + result_3.zero_padding = 0; + result_3.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_3) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides = (((DLTensor*)hc_scale)[0].strides); + void* hc_scale_1 = (((DLTensor*)hc_scale)[0].data); + if ((((DLTensor*)hc_base)[0].ndim) != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_4; + result_4.type_index = kTVMFFINone; + result_4.zero_padding = 0; + result_4.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_4) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides = (((DLTensor*)hc_base)[0].strides); + void* hc_base_1 = (((DLTensor*)hc_base)[0].data); + if ((((DLTensor*)residual)[0].ndim) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_5; + result_5.type_index = kTVMFFINone; + result_5.zero_padding = 0; + result_5.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_5) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_residual_strides = (((DLTensor*)residual)[0].strides); + void* residual_1 = (((DLTensor*)residual)[0].data); + if ((((DLTensor*)post_mix)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_6; + result_6.type_index = kTVMFFINone; + result_6.zero_padding = 0; + result_6.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_6) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides = (((DLTensor*)post_mix)[0].strides); + void* post_mix_1 = (((DLTensor*)post_mix)[0].data); + if ((((DLTensor*)comb_mix)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_7; + result_7.type_index = kTVMFFINone; + result_7.zero_padding = 0; + result_7.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_7) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides = (((DLTensor*)comb_mix)[0].strides); + void* comb_mix_1 = (((DLTensor*)comb_mix)[0].data); + if ((((DLTensor*)layer_input)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_8; + result_8.type_index = kTVMFFINone; + result_8.zero_padding = 0; + result_8.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_8) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides = (((DLTensor*)layer_input)[0].strides); + void* layer_input_1 = (((DLTensor*)layer_input)[0].data); + if ((((DLTensor*)norm_weight)[0].ndim) != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_9; + result_9.type_index = kTVMFFINone; + result_9.zero_padding = 0; + result_9.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_9) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides = (((DLTensor*)norm_weight)[0].strides); + void* norm_weight_1 = (((DLTensor*)norm_weight)[0].data); + if ((((((DLTensor*)gemm_out_mul)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)gemm_out_mul)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)gemm_out_mul)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_10; + result_10.type_index = kTVMFFINone; + result_10.zero_padding = 0; + result_10.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_10) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[0]) != 64) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)64; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_11; + result_11.type_index = kTVMFFINone; + result_11.zero_padding = 0; + result_11.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_11) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[2]) != 24) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)24; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[2])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_12; + result_12.type_index = kTVMFFINone; + result_12.zero_padding = 0; + result_12.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_12) != 0) { + return -1; + } + } + int32_t condval; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval = 1; + } else { + condval = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[2]); + } + if (condval != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_1; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval_1 = 1; + } else { + condval_1 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[2]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_1); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_13; + result_13.type_index = kTVMFFINone; + result_13.zero_padding = 0; + result_13.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_13) != 0) { + return -1; + } + } + int32_t condval_2; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval_2 = 1; + } else { + condval_2 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[1]); + } + if ((condval_2 != 24) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_14; + result_14.type_index = kTVMFFINone; + result_14.zero_padding = 0; + result_14.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_14) != 0) { + return -1; + } + } + int32_t condval_3; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval_3 = 1; + } else { + condval_3 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[0]); + } + if (((num_tokens * 24) != condval_3) && (num_tokens != 0)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_15; + result_15.type_index = kTVMFFINone; + result_15.zero_padding = 0; + result_15.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_15) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)gemm_out_mul)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_16; + result_16.type_index = kTVMFFINone; + result_16.zero_padding = 0; + result_16.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_16) != 0) { + return -1; + } + } + if ((((DLTensor*)gemm_out_mul)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_17; + result_17.type_index = kTVMFFINone; + result_17.zero_padding = 0; + result_17.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_17) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (gemm_out_mul_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_18; + result_18.type_index = kTVMFFINone; + result_18.zero_padding = 0; + result_18.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_18) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)gemm_out_sqrsum)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)gemm_out_sqrsum)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)gemm_out_sqrsum)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_19; + result_19.type_index = kTVMFFINone; + result_19.zero_padding = 0; + result_19.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_19) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[0]) != 64) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)64; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_20; + result_20.type_index = kTVMFFINone; + result_20.zero_padding = 0; + result_20.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_20) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[1])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_21; + result_21.type_index = kTVMFFINone; + result_21.zero_padding = 0; + result_21.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_21) != 0) { + return -1; + } + } + int32_t condval_4; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides == NULL)) { + condval_4 = 1; + } else { + condval_4 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides)[1]); + } + if ((condval_4 != 1) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_22; + result_22.type_index = kTVMFFINone; + result_22.zero_padding = 0; + result_22.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_22) != 0) { + return -1; + } + } + int32_t condval_5; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides == NULL)) { + condval_5 = 1; + } else { + condval_5 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides)[0]); + } + if ((((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != condval_5) && (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != 0)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_23; + result_23.type_index = kTVMFFINone; + result_23.zero_padding = 0; + result_23.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_23) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)gemm_out_sqrsum)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_24; + result_24.type_index = kTVMFFINone; + result_24.zero_padding = 0; + result_24.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_24) != 0) { + return -1; + } + } + if ((((DLTensor*)gemm_out_sqrsum)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_25; + result_25.type_index = kTVMFFINone; + result_25.zero_padding = 0; + result_25.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_25) != 0) { + return -1; + } + } + if ((((DLTensor*)gemm_out_sqrsum)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_26; + result_26.type_index = kTVMFFINone; + result_26.zero_padding = 0; + result_26.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_26) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (gemm_out_sqrsum_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_27; + result_27.type_index = kTVMFFINone; + result_27.zero_padding = 0; + result_27.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_27) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)hc_scale)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)hc_scale)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)hc_scale)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_28; + result_28.type_index = kTVMFFINone; + result_28.zero_padding = 0; + result_28.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_28) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_shape)[0]) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_29; + result_29.type_index = kTVMFFINone; + result_29.zero_padding = 0; + result_29.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_29) != 0) { + return -1; + } + } + int32_t condval_6; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides == NULL)) { + condval_6 = 1; + } else { + condval_6 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides)[0]); + } + if (condval_6 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_7; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides == NULL)) { + condval_7 = 1; + } else { + condval_7 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides)[0]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_7); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_30; + result_30.type_index = kTVMFFINone; + result_30.zero_padding = 0; + result_30.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_30) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)hc_scale)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_31; + result_31.type_index = kTVMFFINone; + result_31.zero_padding = 0; + result_31.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_31) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_scale)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_32; + result_32.type_index = kTVMFFINone; + result_32.zero_padding = 0; + result_32.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_32) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_scale)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_33; + result_33.type_index = kTVMFFINone; + result_33.zero_padding = 0; + result_33.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_33) != 0) { + return -1; + } + } + if (hc_scale_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_34; + result_34.type_index = kTVMFFINone; + result_34.zero_padding = 0; + result_34.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_34) != 0) { + return -1; + } + } + if ((((((DLTensor*)hc_base)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)hc_base)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)hc_base)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_35; + result_35.type_index = kTVMFFINone; + result_35.zero_padding = 0; + result_35.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_35) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_shape)[0]) != 24) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)24; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_36; + result_36.type_index = kTVMFFINone; + result_36.zero_padding = 0; + result_36.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_36) != 0) { + return -1; + } + } + int32_t condval_8; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides == NULL)) { + condval_8 = 1; + } else { + condval_8 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides)[0]); + } + if (condval_8 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_9; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides == NULL)) { + condval_9 = 1; + } else { + condval_9 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides)[0]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_9); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_37; + result_37.type_index = kTVMFFINone; + result_37.zero_padding = 0; + result_37.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_37) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)hc_base)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_38; + result_38.type_index = kTVMFFINone; + result_38.zero_padding = 0; + result_38.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_38) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_base)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_39; + result_39.type_index = kTVMFFINone; + result_39.zero_padding = 0; + result_39.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_39) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_base)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_40; + result_40.type_index = kTVMFFINone; + result_40.zero_padding = 0; + result_40.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_40) != 0) { + return -1; + } + } + if (hc_base_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_41; + result_41.type_index = kTVMFFINone; + result_41.zero_padding = 0; + result_41.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_41) != 0) { + return -1; + } + } + if ((((((DLTensor*)residual)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)residual)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)residual)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)residual)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)residual)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_42; + result_42.type_index = kTVMFFINone; + result_42.zero_padding = 0; + result_42.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_42) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_43; + result_43.type_index = kTVMFFINone; + result_43.zero_padding = 0; + result_43.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_43) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[1]) != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_44; + result_44.type_index = kTVMFFINone; + result_44.zero_padding = 0; + result_44.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_44) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[2]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[2])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_45; + result_45.type_index = kTVMFFINone; + result_45.zero_padding = 0; + result_45.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_45) != 0) { + return -1; + } + } + int32_t condval_10; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_10 = 1; + } else { + condval_10 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[2]); + } + if (condval_10 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_11; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_11 = 1; + } else { + condval_11 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[2]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_11); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_46; + result_46.type_index = kTVMFFINone; + result_46.zero_padding = 0; + result_46.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_46) != 0) { + return -1; + } + } + int32_t condval_12; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_12 = 1; + } else { + condval_12 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[1]); + } + if (condval_12 != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_13; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_13 = 1; + } else { + condval_13 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_13); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_47; + result_47.type_index = kTVMFFINone; + result_47.zero_padding = 0; + result_47.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_47) != 0) { + return -1; + } + } + int32_t condval_14; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_14 = 1; + } else { + condval_14 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[0]); + } + if ((condval_14 != 16384) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_48; + result_48.type_index = kTVMFFINone; + result_48.zero_padding = 0; + result_48.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_48) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)residual)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_49; + result_49.type_index = kTVMFFINone; + result_49.zero_padding = 0; + result_49.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_49) != 0) { + return -1; + } + } + if ((((DLTensor*)residual)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)residual)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_50; + result_50.type_index = kTVMFFINone; + result_50.zero_padding = 0; + result_50.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_50) != 0) { + return -1; + } + } + if ((((DLTensor*)residual)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_51; + result_51.type_index = kTVMFFINone; + result_51.zero_padding = 0; + result_51.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_51) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (residual_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_52; + result_52.type_index = kTVMFFINone; + result_52.zero_padding = 0; + result_52.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_52) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)post_mix)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)post_mix)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)post_mix)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_53; + result_53.type_index = kTVMFFINone; + result_53.zero_padding = 0; + result_53.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_53) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_54; + result_54.type_index = kTVMFFINone; + result_54.zero_padding = 0; + result_54.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_54) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[1]) != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_55; + result_55.type_index = kTVMFFINone; + result_55.zero_padding = 0; + result_55.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_55) != 0) { + return -1; + } + } + int32_t condval_15; + if ((mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides == NULL)) { + condval_15 = 1; + } else { + condval_15 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides)[1]); + } + if (condval_15 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_16; + if ((mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides == NULL)) { + condval_16 = 1; + } else { + condval_16 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_16); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_56; + result_56.type_index = kTVMFFINone; + result_56.zero_padding = 0; + result_56.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_56) != 0) { + return -1; + } + } + int32_t condval_17; + if ((mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides == NULL)) { + condval_17 = 1; + } else { + condval_17 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides)[0]); + } + if ((condval_17 != 4) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_57; + result_57.type_index = kTVMFFINone; + result_57.zero_padding = 0; + result_57.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_57) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)post_mix)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_58; + result_58.type_index = kTVMFFINone; + result_58.zero_padding = 0; + result_58.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_58) != 0) { + return -1; + } + } + if ((((DLTensor*)post_mix)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_59; + result_59.type_index = kTVMFFINone; + result_59.zero_padding = 0; + result_59.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_59) != 0) { + return -1; + } + } + if ((((DLTensor*)post_mix)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_60; + result_60.type_index = kTVMFFINone; + result_60.zero_padding = 0; + result_60.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_60) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (post_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_61; + result_61.type_index = kTVMFFINone; + result_61.zero_padding = 0; + result_61.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_61) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)comb_mix)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)comb_mix)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)comb_mix)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_62; + result_62.type_index = kTVMFFINone; + result_62.zero_padding = 0; + result_62.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_62) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_63; + result_63.type_index = kTVMFFINone; + result_63.zero_padding = 0; + result_63.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_63) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[1]) != 16) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_64; + result_64.type_index = kTVMFFINone; + result_64.zero_padding = 0; + result_64.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_64) != 0) { + return -1; + } + } + int32_t condval_18; + if ((mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides == NULL)) { + condval_18 = 1; + } else { + condval_18 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides)[1]); + } + if (condval_18 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_19; + if ((mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides == NULL)) { + condval_19 = 1; + } else { + condval_19 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_19); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_65; + result_65.type_index = kTVMFFINone; + result_65.zero_padding = 0; + result_65.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_65) != 0) { + return -1; + } + } + int32_t condval_20; + if ((mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides == NULL)) { + condval_20 = 1; + } else { + condval_20 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides)[0]); + } + if ((condval_20 != 16) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_66; + result_66.type_index = kTVMFFINone; + result_66.zero_padding = 0; + result_66.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_66) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)comb_mix)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_67; + result_67.type_index = kTVMFFINone; + result_67.zero_padding = 0; + result_67.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_67) != 0) { + return -1; + } + } + if ((((DLTensor*)comb_mix)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_68; + result_68.type_index = kTVMFFINone; + result_68.zero_padding = 0; + result_68.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_68) != 0) { + return -1; + } + } + if ((((DLTensor*)comb_mix)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_69; + result_69.type_index = kTVMFFINone; + result_69.zero_padding = 0; + result_69.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_69) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (comb_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_70; + result_70.type_index = kTVMFFINone; + result_70.zero_padding = 0; + result_70.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_70) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)layer_input)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)layer_input)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)layer_input)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_71; + result_71.type_index = kTVMFFINone; + result_71.zero_padding = 0; + result_71.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_71) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_72; + result_72.type_index = kTVMFFINone; + result_72.zero_padding = 0; + result_72.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_72) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[1]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_73; + result_73.type_index = kTVMFFINone; + result_73.zero_padding = 0; + result_73.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_73) != 0) { + return -1; + } + } + int32_t condval_21; + if ((mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides == NULL)) { + condval_21 = 1; + } else { + condval_21 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides)[1]); + } + if (condval_21 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_22; + if ((mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides == NULL)) { + condval_22 = 1; + } else { + condval_22 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_22); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_74; + result_74.type_index = kTVMFFINone; + result_74.zero_padding = 0; + result_74.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_74) != 0) { + return -1; + } + } + int32_t condval_23; + if ((mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides == NULL)) { + condval_23 = 1; + } else { + condval_23 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides)[0]); + } + if ((condval_23 != 4096) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_75; + result_75.type_index = kTVMFFINone; + result_75.zero_padding = 0; + result_75.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_75) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)layer_input)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_76; + result_76.type_index = kTVMFFINone; + result_76.zero_padding = 0; + result_76.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_76) != 0) { + return -1; + } + } + if ((((DLTensor*)layer_input)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_77; + result_77.type_index = kTVMFFINone; + result_77.zero_padding = 0; + result_77.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_77) != 0) { + return -1; + } + } + if ((((DLTensor*)layer_input)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_78; + result_78.type_index = kTVMFFINone; + result_78.zero_padding = 0; + result_78.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_78) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (layer_input_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_79; + result_79.type_index = kTVMFFINone; + result_79.zero_padding = 0; + result_79.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_79) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)norm_weight)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)norm_weight)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)norm_weight)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_80; + result_80.type_index = kTVMFFINone; + result_80.zero_padding = 0; + result_80.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_80) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_shape)[0]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_81; + result_81.type_index = kTVMFFINone; + result_81.zero_padding = 0; + result_81.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_81) != 0) { + return -1; + } + } + int32_t condval_24; + if ((mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides == NULL)) { + condval_24 = 1; + } else { + condval_24 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides)[0]); + } + if (condval_24 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_25; + if ((mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides == NULL)) { + condval_25 = 1; + } else { + condval_25 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides)[0]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_25); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_82; + result_82.type_index = kTVMFFINone; + result_82.zero_padding = 0; + result_82.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_82) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)norm_weight)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_83; + result_83.type_index = kTVMFFINone; + result_83.zero_padding = 0; + result_83.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_83) != 0) { + return -1; + } + } + if ((((DLTensor*)norm_weight)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_84; + result_84.type_index = kTVMFFINone; + result_84.zero_padding = 0; + result_84.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_84) != 0) { + return -1; + } + } + if ((((DLTensor*)norm_weight)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_85; + result_85.type_index = kTVMFFINone; + result_85.zero_padding = 0; + result_85.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_85) != 0) { + return -1; + } + } + if (norm_weight_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_86; + result_86.type_index = kTVMFFINone; + result_86.zero_padding = 0; + result_86.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_86) != 0) { + return -1; + } + } + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = ((int64_t)2); + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = ((int64_t)dev_id); + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + if (__tvm_set_device_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_set_device", &__tvm_set_device_packed) != 0) { + return -1; + } + } + TVMFFIAny result_87; + result_87.type_index = kTVMFFINone; + result_87.zero_padding = 0; + result_87.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_set_device_packed, (TVMFFIAny*) stack_ffi_any, 2, &result_87) != 0) { + return -1; + } + if (comb_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = comb_mix_1; + if (gemm_out_mul_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = gemm_out_mul_1; + if (gemm_out_sqrsum_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = gemm_out_sqrsum_1; + if (hc_base_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_ptr) = hc_base_1; + if (hc_scale_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_ptr) = hc_scale_1; + if (layer_input_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_ptr) = layer_input_1; + if (norm_weight_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_ptr) = norm_weight_1; + if (post_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_ptr) = post_mix_1; + if (residual_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_ptr) = residual_1; + (((TVMFFIAny*)stack_ffi_any)[9].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[9].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[9].v_int64) = ((int64_t)num_tokens); + (((TVMFFIAny*)stack_ffi_any)[10].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[10].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[10].v_int64) = ((int64_t)num_tokens); + (((TVMFFIAny*)stack_ffi_any)[11].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[11].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[11].v_int64) = ((int64_t)96); + (((TVMFFIAny*)stack_ffi_any)[12].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[12].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[12].v_int64) = ((int64_t)1); + (((TVMFFIAny*)stack_ffi_any)[13].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[13].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[13].v_int64) = ((int64_t)1); + (((TVMFFIAny*)stack_ffi_any)[14].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[14].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[14].v_int64) = ((int64_t)29040); + (((TVMFFIAny*)stack_ffi_any)[15].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[15].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[15].v_int64) = (int64_t)0; + if (mhc_pre_big_fuse_with_norm_tilelang_kernel_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "mhc_pre_big_fuse_with_norm_tilelang_kernel", &mhc_pre_big_fuse_with_norm_tilelang_kernel_packed) != 0) { + return -1; + } + } + TVMFFIAny result_88; + result_88.type_index = kTVMFFINone; + result_88.zero_padding = 0; + result_88.v_int64 = 0; + if (TVMFFIFunctionCall(mhc_pre_big_fuse_with_norm_tilelang_kernel_packed, (TVMFFIAny*) stack_ffi_any, 15, &result_88) != 0) { + return -1; + } + return 0; +} + +// CodegenC: NOTE: Auto-generated entry function +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_main(void* self, void* args,int num_args, void* result) { + return __tvm_ffi_mhc_pre_big_fuse_with_norm_tilelang(self, args, num_args, result); +} diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/0f368e85ad91dc38d1eca212e6350c2e26e5f453a6c404b9ceb10dca001fe742/params.pkl b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/0f368e85ad91dc38d1eca212e6350c2e26e5f453a6c404b9ceb10dca001fe742/params.pkl new file mode 100644 index 0000000..4e19dea Binary files /dev/null and b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/0f368e85ad91dc38d1eca212e6350c2e26e5f453a6c404b9ceb10dca001fe742/params.pkl differ diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/147eb04270024c36acaf2922c18e38bbdfc222673231f206ebd108766e937d6c/device_kernel.cu b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/147eb04270024c36acaf2922c18e38bbdfc222673231f206ebd108766e937d6c/device_kernel.cu new file mode 100644 index 0000000..5003c21 --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/147eb04270024c36acaf2922c18e38bbdfc222673231f206ebd108766e937d6c/device_kernel.cu @@ -0,0 +1,424 @@ +#include +#include +#include +#include +#include +#include +#include +#ifdef ENABLE_BF16 +#include +#endif + +extern "C" __global__ void mhc_pre_big_fuse_with_norm_tilelang_kernel(float* comb_mix, const float* gemm_out_mul, const float* gemm_out_sqrsum, const float* hc_base, const float* hc_scale, bfloat16_t* layer_input, const bfloat16_t* norm_weight, float* post_mix, const bfloat16_t* residual, int num_tokens); +extern "C" __global__ void __launch_bounds__(96, 1) mhc_pre_big_fuse_with_norm_tilelang_kernel(float* comb_mix, const float* gemm_out_mul, const float* gemm_out_sqrsum, const float* hc_base, const float* hc_scale, bfloat16_t* layer_input, const bfloat16_t* norm_weight, float* post_mix, const bfloat16_t* residual, int num_tokens) { + extern __shared__ __align__(1024) uchar buf_dyn_shmem[]; + float mixes[1]; + float rms[1]; + float cm[1]; + float row_max[1]; + float row_sum[1]; + float col_sum[1]; + float sumsq_per_pos[16]; + float sumsq[1]; + float rsqrt_norm[1]; + float xl[64]; + float ol[16]; + bfloat16_t xs_local_cast[8]; + bfloat16_t xs_local_cast_1[8]; + bfloat16_t xs_local_cast_2[8]; + float w_local[16]; + float ol_1[16]; + bfloat16_t w_shared_local_cast_3[8]; + bfloat16_t output_shared_local_cast_4[8]; + bfloat16_t layer_input_local_cast_5[8]; + bfloat16_t w_shared_local_cast_6[8]; + bfloat16_t output_shared_local_cast_7[8]; + bfloat16_t layer_input_local_cast_8[8]; + bfloat16_t w_shared_local_cast_9[8]; + bfloat16_t output_shared_local_cast_10[8]; + bfloat16_t layer_input_local_cast_11[8]; + mixes[0] = 0x0p+0f/*0.000000e+00*/; + rms[0] = 0x0p+0f/*0.000000e+00*/; + cudaGridDependencySynchronize(); + for (int i_split = 0; i_split < 11; ++i_split) { + rms[0] = (rms[0] + gemm_out_sqrsum[((((int64_t)i_split) * ((int64_t)num_tokens)) + ((int64_t)((int)blockIdx.x)))]); + } + rms[0] = rsqrtf(((rms[0] / 0x1p+14f/*1.638400e+04*/) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + mixes[0] = 0x0p+0f/*0.000000e+00*/; + for (int i_split_1 = 0; i_split_1 < 11; ++i_split_1) { + mixes[0] = (mixes[0] + gemm_out_mul[(((((int64_t)((int)blockIdx.x)) * (int64_t)24) + ((((int64_t)i_split_1) * ((int64_t)num_tokens)) * (int64_t)24)) + (((int64_t)((int)threadIdx.x)) % (int64_t)24))]); + } + mixes[0] = (mixes[0] * rms[0]); + if ((((int)threadIdx.x) / 24) == 0) { + ((float*)buf_dyn_shmem)[(((int)threadIdx.x) % 24)] = mixes[0]; + } + __syncthreads(); + if (((int)threadIdx.x) < 32) { + if (((int)threadIdx.x) < 4) { + post_mix[((((int64_t)((int)blockIdx.x)) * (int64_t)4) + ((int64_t)((int)threadIdx.x)))] = ((0x1p+0f/*1.000000e+00*/ / (0x1p+0f/*1.000000e+00*/ + expf((0x0p+0f/*0.000000e+00*/ - ((((float*)buf_dyn_shmem)[(((int)threadIdx.x) + 4)] * hc_scale[1]) + hc_base[(((int)threadIdx.x) + 4)]))))) * 0x1p+1f/*2.000000e+00*/); + } + cm[0] = ((((float*)buf_dyn_shmem)[((((int)threadIdx.x) & 15) + 8)] * hc_scale[2]) + hc_base[((((int)threadIdx.x) & 15) + 8)]); + row_max[0] = -CUDART_INF_F; + row_max[0] = max(row_max[0], cm[0]); + row_max[0] = tl::AllReduce>::run(row_max[0]); + cm[0] = expf((cm[0] - row_max[0])); + row_sum[0] = 0x0p+0f/*0.000000e+00*/; + row_sum[0] = (row_sum[0] + cm[0]); + row_sum[0] = tl::AllReduce>::run(row_sum[0]); + cm[0] = ((cm[0] / row_sum[0]) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/); + col_sum[0] = 0x0p+0f/*0.000000e+00*/; + col_sum[0] = (col_sum[0] + cm[0]); + col_sum[0] = tl::AllReduce>::run(col_sum[0]); + cm[0] = (cm[0] / (col_sum[0] + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + for (int __1 = 0; __1 < 19; ++__1) { + row_sum[0] = 0x0p+0f/*0.000000e+00*/; + row_sum[0] = (row_sum[0] + cm[0]); + row_sum[0] = tl::AllReduce>::run(row_sum[0]); + cm[0] = (cm[0] / (row_sum[0] + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + col_sum[0] = 0x0p+0f/*0.000000e+00*/; + col_sum[0] = (col_sum[0] + cm[0]); + col_sum[0] = tl::AllReduce>::run(col_sum[0]); + cm[0] = (cm[0] / (col_sum[0] + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + } + if ((((int)threadIdx.x) >> 4) == 0) { + comb_mix[((((int64_t)((int)blockIdx.x)) * (int64_t)16) + (((int64_t)((int)threadIdx.x)) & (int64_t)15))] = cm[0]; + } + } else { + if (((int)threadIdx.x) < 36) { + ((float*)buf_dyn_shmem)[(((int)threadIdx.x) + 7224)] = ((0x1p+0f/*1.000000e+00*/ / (0x1p+0f/*1.000000e+00*/ + expf((0x0p+0f/*0.000000e+00*/ - ((((float*)buf_dyn_shmem)[(((int)threadIdx.x) - 32)] * hc_scale[0]) + hc_base[(((int)threadIdx.x) - 32)]))))) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/); + } + #pragma unroll + for (int i = 0; i < 4; ++i) { + float broadcast_var = 0x0p+0f/*0.000000e+00*/; + *(float4*)(sumsq_per_pos + (i * 4)) = make_float4(broadcast_var, broadcast_var, broadcast_var, broadcast_var); + } + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_1 = 0; i_1 < 8; ++i_1) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i_1 >> 1) * 1024) + (((((i_1 * 64) + ((int)threadIdx.x)) + 96) & 127) * 8)) + 48)])), (&(residual[(((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + ((((int64_t)i_1) >> (int64_t)1) * (int64_t)4096)) + (((((((int64_t)i_1) * (int64_t)64) + ((int64_t)((int)threadIdx.x))) + (int64_t)96) & (int64_t)127) * (int64_t)8))]))); + } + tl::cp_async_commit(); + #pragma unroll + for (int i_2 = 0; i_2 < 8; ++i_2) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i_2 >> 1) * 1024) + (((((i_2 * 64) + ((int)threadIdx.x)) + 96) & 127) * 8)) + 4144)])), (&(residual[((((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + ((((int64_t)i_2) >> (int64_t)1) * (int64_t)4096)) + (((((((int64_t)i_2) * (int64_t)64) + ((int64_t)((int)threadIdx.x))) + (int64_t)96) & (int64_t)127) * (int64_t)8)) + (int64_t)1024)]))); + } + tl::cp_async_commit(); + for (int i0_h = 0; i0_h < 2; ++i0_h) { + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_3 = 0; i_3 < 8; ++i_3) { + *(uint4*)(xs_local_cast + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + ((((i0_h * 4096) + (i_3 * 512)) + (((int)threadIdx.x) * 8)) - 208)); + for (int vec = 0; vec < 2; ++vec) { + float4 __2; + uint2 v_ = *(uint2*)(xs_local_cast + (vec * 4)); + ((float2*)(&__2))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v_))[0]); + ((float2*)(&__2))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v_))[1]); + *(float4*)(xl + ((i_3 * 8) + (vec * 4))) = __2; + } + } + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_4 = 0; i_4 < 8; ++i_4) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i0_h * 4096) + ((i_4 >> 1) * 1024)) + (((((i_4 * 64) + ((int)threadIdx.x)) + 96) & 127) * 8)) + 48)])), (&(residual[(((((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + ((((int64_t)i_4) >> (int64_t)1) * (int64_t)4096)) + (((int64_t)i0_h) * (int64_t)1024)) + (((((((int64_t)i_4) * (int64_t)64) + ((int64_t)((int)threadIdx.x))) + (int64_t)96) & (int64_t)127) * (int64_t)8)) + (int64_t)2048)]))); + } + tl::cp_async_commit(); + #pragma unroll + for (int i_5 = 0; i_5 < 4; ++i_5) { + float broadcast_var_1 = 0x0p+0f/*0.000000e+00*/; + *(float4*)(ol + (i_5 * 4)) = make_float4(broadcast_var_1, broadcast_var_1, broadcast_var_1, broadcast_var_1); + } + tl::__sync_thread_partial<3, 64>(); + for (int i_hc = 0; i_hc < 4; ++i_hc) { + float pre = ((float*)buf_dyn_shmem)[(i_hc + 7256)]; + #pragma unroll + for (int i_6 = 0; i_6 < 16; ++i_6) { + ol[i_6] = (ol[i_6] + (pre * xl[((i_hc * 16) + i_6)])); + } + } + #pragma unroll + for (int i_7 = 0; i_7 < 4; ++i_7) { + float4 __3; + float4 v__1 = *(float4*)(sumsq_per_pos + (i_7 * 4)); + float4 __4; + float4 v__2 = *(float4*)(ol + (i_7 * 4)); + __4.x = (v__2.x*v__2.x); + __4.y = (v__2.y*v__2.y); + __4.z = (v__2.z*v__2.z); + __4.w = (v__2.w*v__2.w); + __3.x = (v__1.x+__4.x); + __3.y = (v__1.y+__4.y); + __3.z = (v__1.z+__4.z); + __3.w = (v__1.w+__4.w); + *(float4*)(sumsq_per_pos + (i_7 * 4)) = __3; + uint2 __5; + float4 v__3 = *(float4*)(ol + (i_7 * 4)); + (reinterpret_cast<__nv_bfloat162*>(&__5))[0] = __float22bfloat162_rn(((float2*)(&v__3))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__5))[1] = __float22bfloat162_rn(((float2*)(&v__3))[1]); + *(uint2*)(((bfloat16_t*)buf_dyn_shmem) + (((((i0_h * 1024) + ((i_7 >> 1) * 512)) + (((int)threadIdx.x) * 8)) + ((i_7 & 1) * 4)) + 7984)) = __5; + } + } + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_8 = 0; i_8 < 8; ++i_8) { + *(uint4*)(xs_local_cast_1 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_8 * 512) + (((int)threadIdx.x) * 8)) - 208)); + for (int vec_1 = 0; vec_1 < 2; ++vec_1) { + float4 __6; + uint2 v__4 = *(uint2*)(xs_local_cast_1 + (vec_1 * 4)); + ((float2*)(&__6))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__4))[0]); + ((float2*)(&__6))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__4))[1]); + *(float4*)(xl + ((i_8 * 8) + (vec_1 * 4))) = __6; + } + } + #pragma unroll + for (int i_9 = 0; i_9 < 4; ++i_9) { + float broadcast_var_2 = 0x0p+0f/*0.000000e+00*/; + *(float4*)(ol + (i_9 * 4)) = make_float4(broadcast_var_2, broadcast_var_2, broadcast_var_2, broadcast_var_2); + } + for (int i_hc_1 = 0; i_hc_1 < 4; ++i_hc_1) { + float pre_1 = ((float*)buf_dyn_shmem)[(i_hc_1 + 7256)]; + #pragma unroll + for (int i_10 = 0; i_10 < 16; ++i_10) { + ol[i_10] = (ol[i_10] + (pre_1 * xl[((i_hc_1 * 16) + i_10)])); + } + } + #pragma unroll + for (int i_11 = 0; i_11 < 4; ++i_11) { + float4 __7; + float4 v__5 = *(float4*)(sumsq_per_pos + (i_11 * 4)); + float4 __8; + float4 v__6 = *(float4*)(ol + (i_11 * 4)); + __8.x = (v__6.x*v__6.x); + __8.y = (v__6.y*v__6.y); + __8.z = (v__6.z*v__6.z); + __8.w = (v__6.w*v__6.w); + __7.x = (v__5.x+__8.x); + __7.y = (v__5.y+__8.y); + __7.z = (v__5.z+__8.z); + __7.w = (v__5.w+__8.w); + *(float4*)(sumsq_per_pos + (i_11 * 4)) = __7; + uint2 __9; + float4 v__7 = *(float4*)(ol + (i_11 * 4)); + (reinterpret_cast<__nv_bfloat162*>(&__9))[0] = __float22bfloat162_rn(((float2*)(&v__7))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__9))[1] = __float22bfloat162_rn(((float2*)(&v__7))[1]); + *(uint2*)(((bfloat16_t*)buf_dyn_shmem) + (((((i_11 >> 1) * 512) + (((int)threadIdx.x) * 8)) + ((i_11 & 1) * 4)) + 10032)) = __9; + } + tl::cp_async_wait<0>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_12 = 0; i_12 < 8; ++i_12) { + *(uint4*)(xs_local_cast_2 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_12 * 512) + (((int)threadIdx.x) * 8)) + 3888)); + for (int vec_2 = 0; vec_2 < 2; ++vec_2) { + float4 __10; + uint2 v__8 = *(uint2*)(xs_local_cast_2 + (vec_2 * 4)); + ((float2*)(&__10))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__8))[0]); + ((float2*)(&__10))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__8))[1]); + *(float4*)(xl + ((i_12 * 8) + (vec_2 * 4))) = __10; + } + } + #pragma unroll + for (int i_13 = 0; i_13 < 4; ++i_13) { + float broadcast_var_3 = 0x0p+0f/*0.000000e+00*/; + *(float4*)(ol + (i_13 * 4)) = make_float4(broadcast_var_3, broadcast_var_3, broadcast_var_3, broadcast_var_3); + } + for (int i_hc_2 = 0; i_hc_2 < 4; ++i_hc_2) { + float pre_2 = ((float*)buf_dyn_shmem)[(i_hc_2 + 7256)]; + #pragma unroll + for (int i_14 = 0; i_14 < 16; ++i_14) { + ol[i_14] = (ol[i_14] + (pre_2 * xl[((i_hc_2 * 16) + i_14)])); + } + } + #pragma unroll + for (int i_15 = 0; i_15 < 4; ++i_15) { + float4 __11; + float4 v__9 = *(float4*)(sumsq_per_pos + (i_15 * 4)); + float4 __12; + float4 v__10 = *(float4*)(ol + (i_15 * 4)); + __12.x = (v__10.x*v__10.x); + __12.y = (v__10.y*v__10.y); + __12.z = (v__10.z*v__10.z); + __12.w = (v__10.w*v__10.w); + __11.x = (v__9.x+__12.x); + __11.y = (v__9.y+__12.y); + __11.z = (v__9.z+__12.z); + __11.w = (v__9.w+__12.w); + *(float4*)(sumsq_per_pos + (i_15 * 4)) = __11; + uint2 __13; + float4 v__11 = *(float4*)(ol + (i_15 * 4)); + (reinterpret_cast<__nv_bfloat162*>(&__13))[0] = __float22bfloat162_rn(((float2*)(&v__11))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__13))[1] = __float22bfloat162_rn(((float2*)(&v__11))[1]); + *(uint2*)(((bfloat16_t*)buf_dyn_shmem) + (((((i_15 >> 1) * 512) + (((int)threadIdx.x) * 8)) + ((i_15 & 1) * 4)) + 11056)) = __13; + } + sumsq[0] = 0x0p+0f/*0.000000e+00*/; + #pragma unroll + for (int rv = 0; rv < 16; ++rv) { + sumsq[0] = (sumsq[0] + sumsq_per_pos[(((rv & 1) * 8) + (rv >> 1))]); + } + tl::__sync_thread_partial<3, 64>(); + sumsq[0] = tl::AllReduce>::run(sumsq[0], (&(((float*)buf_dyn_shmem)[7192]))); + rsqrt_norm[0] = rsqrtf(((sumsq[0] / 0x1p+12f/*4.096000e+03*/) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + #pragma unroll + for (int i_16 = 0; i_16 < 2; ++i_16) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[(((i_16 * 512) + (((int)threadIdx.x) * 8)) + 12080)])), (&(norm_weight[(((i_16 * 512) + (((int)threadIdx.x) * 8)) - 256)]))); + } + tl::cp_async_commit(); + #pragma unroll + for (int i_17 = 0; i_17 < 2; ++i_17) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[(((i_17 * 512) + (((int)threadIdx.x) * 8)) + 13104)])), (&(norm_weight[(((i_17 * 512) + (((int)threadIdx.x) * 8)) + 768)]))); + } + tl::cp_async_commit(); + for (int i0_h_1 = 0; i0_h_1 < 2; ++i0_h_1) { + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_18 = 0; i_18 < 2; ++i_18) { + *(uint4*)(w_shared_local_cast_3 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + ((((i0_h_1 * 1024) + (i_18 * 512)) + (((int)threadIdx.x) * 8)) + 12080)); + for (int vec_3 = 0; vec_3 < 2; ++vec_3) { + float4 __14; + uint2 v__12 = *(uint2*)(w_shared_local_cast_3 + (vec_3 * 4)); + ((float2*)(&__14))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__12))[0]); + ((float2*)(&__14))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__12))[1]); + *(float4*)(w_local + ((i_18 * 8) + (vec_3 * 4))) = __14; + } + } + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_19 = 0; i_19 < 2; ++i_19) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i0_h_1 * 1024) + (i_19 * 512)) + (((int)threadIdx.x) * 8)) + 12080)])), (&(norm_weight[((((i0_h_1 * 1024) + (i_19 * 512)) + (((int)threadIdx.x) * 8)) + 1792)]))); + } + tl::cp_async_commit(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_20 = 0; i_20 < 2; ++i_20) { + *(uint4*)(output_shared_local_cast_4 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + ((((i0_h_1 * 1024) + (i_20 * 512)) + (((int)threadIdx.x) * 8)) + 7984)); + for (int vec_4 = 0; vec_4 < 2; ++vec_4) { + float4 __15; + float4 __16; + float4 __17; + uint2 v__13 = *(uint2*)(output_shared_local_cast_4 + (vec_4 * 4)); + ((float2*)(&__17))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__13))[0]); + ((float2*)(&__17))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__13))[1]); + float4 v__14 = make_float4(rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0]); + __16.x = (__17.x*v__14.x); + __16.y = (__17.y*v__14.y); + __16.z = (__17.z*v__14.z); + __16.w = (__17.w*v__14.w); + float4 v__15 = *(float4*)(w_local + ((i_20 * 8) + (vec_4 * 4))); + __15.x = (__16.x*v__15.x); + __15.y = (__16.y*v__15.y); + __15.z = (__16.z*v__15.z); + __15.w = (__16.w*v__15.w); + *(float4*)(ol_1 + ((i_20 * 8) + (vec_4 * 4))) = __15; + } + } + #pragma unroll + for (int i_21 = 0; i_21 < 2; ++i_21) { + for (int vec_5 = 0; vec_5 < 2; ++vec_5) { + uint2 __18; + float4 v__16 = *(float4*)(ol_1 + ((i_21 * 8) + (vec_5 * 4))); + (reinterpret_cast<__nv_bfloat162*>(&__18))[0] = __float22bfloat162_rn(((float2*)(&v__16))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__18))[1] = __float22bfloat162_rn(((float2*)(&v__16))[1]); + *(uint2*)(layer_input_local_cast_5 + (vec_5 * 4)) = __18; + } + *(uint4*)(layer_input + (((((((int64_t)((int)blockIdx.x)) * (int64_t)4096) + (((int64_t)i0_h_1) * (int64_t)1024)) + (((int64_t)i_21) * (int64_t)512)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8)) - (int64_t)256)) = *(uint4*)(layer_input_local_cast_5 + 0); + } + } + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_22 = 0; i_22 < 2; ++i_22) { + *(uint4*)(w_shared_local_cast_6 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_22 * 512) + (((int)threadIdx.x) * 8)) + 12080)); + for (int vec_6 = 0; vec_6 < 2; ++vec_6) { + float4 __19; + uint2 v__17 = *(uint2*)(w_shared_local_cast_6 + (vec_6 * 4)); + ((float2*)(&__19))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__17))[0]); + ((float2*)(&__19))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__17))[1]); + *(float4*)(w_local + ((i_22 * 8) + (vec_6 * 4))) = __19; + } + } + #pragma unroll + for (int i_23 = 0; i_23 < 2; ++i_23) { + *(uint4*)(output_shared_local_cast_7 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_23 * 512) + (((int)threadIdx.x) * 8)) + 10032)); + for (int vec_7 = 0; vec_7 < 2; ++vec_7) { + float4 __20; + float4 __21; + float4 __22; + uint2 v__18 = *(uint2*)(output_shared_local_cast_7 + (vec_7 * 4)); + ((float2*)(&__22))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__18))[0]); + ((float2*)(&__22))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__18))[1]); + float4 v__19 = make_float4(rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0]); + __21.x = (__22.x*v__19.x); + __21.y = (__22.y*v__19.y); + __21.z = (__22.z*v__19.z); + __21.w = (__22.w*v__19.w); + float4 v__20 = *(float4*)(w_local + ((i_23 * 8) + (vec_7 * 4))); + __20.x = (__21.x*v__20.x); + __20.y = (__21.y*v__20.y); + __20.z = (__21.z*v__20.z); + __20.w = (__21.w*v__20.w); + *(float4*)(ol_1 + ((i_23 * 8) + (vec_7 * 4))) = __20; + } + } + #pragma unroll + for (int i_24 = 0; i_24 < 2; ++i_24) { + for (int vec_8 = 0; vec_8 < 2; ++vec_8) { + uint2 __23; + float4 v__21 = *(float4*)(ol_1 + ((i_24 * 8) + (vec_8 * 4))); + (reinterpret_cast<__nv_bfloat162*>(&__23))[0] = __float22bfloat162_rn(((float2*)(&v__21))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__23))[1] = __float22bfloat162_rn(((float2*)(&v__21))[1]); + *(uint2*)(layer_input_local_cast_8 + (vec_8 * 4)) = __23; + } + *(uint4*)(layer_input + ((((((int64_t)((int)blockIdx.x)) * (int64_t)4096) + (((int64_t)i_24) * (int64_t)512)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8)) + (int64_t)1792)) = *(uint4*)(layer_input_local_cast_8 + 0); + } + tl::cp_async_wait<0>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_25 = 0; i_25 < 2; ++i_25) { + *(uint4*)(w_shared_local_cast_9 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_25 * 512) + (((int)threadIdx.x) * 8)) + 13104)); + for (int vec_9 = 0; vec_9 < 2; ++vec_9) { + float4 __24; + uint2 v__22 = *(uint2*)(w_shared_local_cast_9 + (vec_9 * 4)); + ((float2*)(&__24))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__22))[0]); + ((float2*)(&__24))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__22))[1]); + *(float4*)(w_local + ((i_25 * 8) + (vec_9 * 4))) = __24; + } + } + #pragma unroll + for (int i_26 = 0; i_26 < 2; ++i_26) { + *(uint4*)(output_shared_local_cast_10 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_26 * 512) + (((int)threadIdx.x) * 8)) + 11056)); + for (int vec_10 = 0; vec_10 < 2; ++vec_10) { + float4 __25; + float4 __26; + float4 __27; + uint2 v__23 = *(uint2*)(output_shared_local_cast_10 + (vec_10 * 4)); + ((float2*)(&__27))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__23))[0]); + ((float2*)(&__27))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__23))[1]); + float4 v__24 = make_float4(rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0]); + __26.x = (__27.x*v__24.x); + __26.y = (__27.y*v__24.y); + __26.z = (__27.z*v__24.z); + __26.w = (__27.w*v__24.w); + float4 v__25 = *(float4*)(w_local + ((i_26 * 8) + (vec_10 * 4))); + __25.x = (__26.x*v__25.x); + __25.y = (__26.y*v__25.y); + __25.z = (__26.z*v__25.z); + __25.w = (__26.w*v__25.w); + *(float4*)(ol_1 + ((i_26 * 8) + (vec_10 * 4))) = __25; + } + } + #pragma unroll + for (int i_27 = 0; i_27 < 2; ++i_27) { + for (int vec_11 = 0; vec_11 < 2; ++vec_11) { + uint2 __28; + float4 v__26 = *(float4*)(ol_1 + ((i_27 * 8) + (vec_11 * 4))); + (reinterpret_cast<__nv_bfloat162*>(&__28))[0] = __float22bfloat162_rn(((float2*)(&v__26))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__28))[1] = __float22bfloat162_rn(((float2*)(&v__26))[1]); + *(uint2*)(layer_input_local_cast_11 + (vec_11 * 4)) = __28; + } + *(uint4*)(layer_input + ((((((int64_t)((int)blockIdx.x)) * (int64_t)4096) + (((int64_t)i_27) * (int64_t)512)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8)) + (int64_t)2816)) = *(uint4*)(layer_input_local_cast_11 + 0); + } + } + cudaTriggerProgrammaticLaunchCompletion(); +} + diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/147eb04270024c36acaf2922c18e38bbdfc222673231f206ebd108766e937d6c/host_kernel.cu b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/147eb04270024c36acaf2922c18e38bbdfc222673231f206ebd108766e937d6c/host_kernel.cu new file mode 100644 index 0000000..2c40496 --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/147eb04270024c36acaf2922c18e38bbdfc222673231f206ebd108766e937d6c/host_kernel.cu @@ -0,0 +1,3359 @@ +// tilelang target: c -keys=cpu +#define TVM_EXPORTS +#include "tvm/runtime/base.h" +#include "tvm/runtime/c_backend_api.h" +#include "tvm/ffi/c_api.h" +#include +#include +#include +#ifdef __OBJC__ +#include "tvm/runtime/device_api.h" +#include "tvm/ffi/function.h" +#include +#include +#include +#endif +void* __tvm_ffi__library_ctx = NULL; +static void* __tvm_error_ndim_mismatch_packed = NULL; +static void* __tvm_error_dtype_mismatch_packed = NULL; +static void* __tvm_error_expect_eq_packed = NULL; +static void* __tvm_error_constraint_violation_packed = NULL; +static void* __tvm_error_byte_offset_mismatch_packed = NULL; +static void* __tvm_error_device_type_mismatch_packed = NULL; +static void* __tvm_error_null_ptr_packed = NULL; +static void* __tvm_set_device_packed = NULL; +static void* mhc_pre_big_fuse_with_norm_tilelang_kernel_packed = NULL; +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_mhc_pre_big_fuse_with_norm_tilelang(void* self_handle, void* args, int32_t num_args, void* result); +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_mhc_pre_big_fuse_with_norm_tilelang(void* self_handle, void* args, int32_t num_args, void* result) { + __attribute__((aligned(64))) TVMFFIAny stack[16]; + void* stack_ffi_any = stack; + if (!((num_args == 9))) { + char __tvm_assert_msg_buf[512]; + snprintf(__tvm_assert_msg_buf, 512, "%s; expected: %lld, got: %lld", "mhc_pre_big_fuse_with_norm_tilelang: num_args should be 9", (long long)(num_args), (long long)(9)); + TVMFFIErrorSetRaisedFromCStr("RuntimeError", __tvm_assert_msg_buf); + return -1; + } + if (!(!(args == NULL))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang: args pointer is NULL"); + return -1; + } + int32_t gemm_out_mul_type_index = (((TVMFFIAny*)args)[0].type_index); + if (!(((((gemm_out_mul_type_index == 0) || (gemm_out_mul_type_index == 4)) || (gemm_out_mul_type_index == 7)) || (64 <= gemm_out_mul_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input gemm_out_mul expected pointer or tensor handle"); + return -1; + } + int32_t gemm_out_sqrsum_type_index = (((TVMFFIAny*)args)[1].type_index); + if (!(((((gemm_out_sqrsum_type_index == 0) || (gemm_out_sqrsum_type_index == 4)) || (gemm_out_sqrsum_type_index == 7)) || (64 <= gemm_out_sqrsum_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input gemm_out_sqrsum expected pointer or tensor handle"); + return -1; + } + int32_t hc_scale_type_index = (((TVMFFIAny*)args)[2].type_index); + if (!(((((hc_scale_type_index == 0) || (hc_scale_type_index == 4)) || (hc_scale_type_index == 7)) || (64 <= hc_scale_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input hc_scale expected pointer or tensor handle"); + return -1; + } + int32_t hc_base_type_index = (((TVMFFIAny*)args)[3].type_index); + if (!(((((hc_base_type_index == 0) || (hc_base_type_index == 4)) || (hc_base_type_index == 7)) || (64 <= hc_base_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input hc_base expected pointer or tensor handle"); + return -1; + } + int32_t residual_type_index = (((TVMFFIAny*)args)[4].type_index); + if (!(((((residual_type_index == 0) || (residual_type_index == 4)) || (residual_type_index == 7)) || (64 <= residual_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input residual expected pointer or tensor handle"); + return -1; + } + int32_t post_mix_type_index = (((TVMFFIAny*)args)[5].type_index); + if (!(((((post_mix_type_index == 0) || (post_mix_type_index == 4)) || (post_mix_type_index == 7)) || (64 <= post_mix_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input post_mix expected pointer or tensor handle"); + return -1; + } + int32_t comb_mix_type_index = (((TVMFFIAny*)args)[6].type_index); + if (!(((((comb_mix_type_index == 0) || (comb_mix_type_index == 4)) || (comb_mix_type_index == 7)) || (64 <= comb_mix_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input comb_mix expected pointer or tensor handle"); + return -1; + } + int32_t layer_input_type_index = (((TVMFFIAny*)args)[7].type_index); + if (!(((((layer_input_type_index == 0) || (layer_input_type_index == 4)) || (layer_input_type_index == 7)) || (64 <= layer_input_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input layer_input expected pointer or tensor handle"); + return -1; + } + int32_t norm_weight_type_index = (((TVMFFIAny*)args)[8].type_index); + if (!(((((norm_weight_type_index == 0) || (norm_weight_type_index == 4)) || (norm_weight_type_index == 7)) || (64 <= norm_weight_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input norm_weight expected pointer or tensor handle"); + return -1; + } + void* gemm_out_mul = ((gemm_out_mul_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[0].v_ptr) + 24)) : (((TVMFFIAny*)args)[0].v_ptr)); + void* gemm_out_sqrsum = ((gemm_out_sqrsum_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[1].v_ptr) + 24)) : (((TVMFFIAny*)args)[1].v_ptr)); + void* hc_scale = ((hc_scale_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[2].v_ptr) + 24)) : (((TVMFFIAny*)args)[2].v_ptr)); + void* hc_base = ((hc_base_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[3].v_ptr) + 24)) : (((TVMFFIAny*)args)[3].v_ptr)); + void* residual = ((residual_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[4].v_ptr) + 24)) : (((TVMFFIAny*)args)[4].v_ptr)); + void* post_mix = ((post_mix_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[5].v_ptr) + 24)) : (((TVMFFIAny*)args)[5].v_ptr)); + void* comb_mix = ((comb_mix_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[6].v_ptr) + 24)) : (((TVMFFIAny*)args)[6].v_ptr)); + void* layer_input = ((layer_input_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[7].v_ptr) + 24)) : (((TVMFFIAny*)args)[7].v_ptr)); + void* norm_weight = ((norm_weight_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[8].v_ptr) + 24)) : (((TVMFFIAny*)args)[8].v_ptr)); + bool mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_is_null = (gemm_out_mul == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.gemm_out_mul is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_is_null = (gemm_out_sqrsum == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.gemm_out_sqrsum is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_hc_scale_is_null = (hc_scale == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_hc_scale_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.hc_scale is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_hc_base_is_null = (hc_base == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_hc_base_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.hc_base is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_residual_is_null = (residual == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_residual_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.residual is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_post_mix_is_null = (post_mix == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_post_mix_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.post_mix is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_comb_mix_is_null = (comb_mix == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_comb_mix_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.comb_mix is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_layer_input_is_null = (layer_input == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_layer_input_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.layer_input is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_norm_weight_is_null = (norm_weight == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_norm_weight_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.norm_weight is expected to have non-NULL pointer"); + return -1; + } + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape = (((DLTensor*)gemm_out_mul)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape = (((DLTensor*)gemm_out_sqrsum)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_hc_scale_shape = (((DLTensor*)hc_scale)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_hc_base_shape = (((DLTensor*)hc_base)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_residual_shape = (((DLTensor*)residual)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape = (((DLTensor*)post_mix)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape = (((DLTensor*)comb_mix)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape = (((DLTensor*)layer_input)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_norm_weight_shape = (((DLTensor*)norm_weight)[0].shape); + if ((((DLTensor*)gemm_out_mul)[0].ndim) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_1; + result_1.type_index = kTVMFFINone; + result_1.zero_padding = 0; + result_1.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_1) != 0) { + return -1; + } + } + if (!((bool)1)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "Symbolic shape variable num_tokens requires at least one non-null buffer among: mhc_pre_big_fuse_with_norm_tilelang.gemm_out_mul, mhc_pre_big_fuse_with_norm_tilelang.gemm_out_sqrsum, mhc_pre_big_fuse_with_norm_tilelang.residual, mhc_pre_big_fuse_with_norm_tilelang.post_mix, mhc_pre_big_fuse_with_norm_tilelang.comb_mix, mhc_pre_big_fuse_with_norm_tilelang.layer_input"); + return -1; + } + int32_t num_tokens = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]); + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides = (((DLTensor*)gemm_out_mul)[0].strides); + int32_t dev_id = (((DLTensor*)gemm_out_mul)[0].device.device_id); + void* gemm_out_mul_1 = (((DLTensor*)gemm_out_mul)[0].data); + if ((((DLTensor*)gemm_out_sqrsum)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_2; + result_2.type_index = kTVMFFINone; + result_2.zero_padding = 0; + result_2.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_2) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides = (((DLTensor*)gemm_out_sqrsum)[0].strides); + void* gemm_out_sqrsum_1 = (((DLTensor*)gemm_out_sqrsum)[0].data); + if ((((DLTensor*)hc_scale)[0].ndim) != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_3; + result_3.type_index = kTVMFFINone; + result_3.zero_padding = 0; + result_3.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_3) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides = (((DLTensor*)hc_scale)[0].strides); + void* hc_scale_1 = (((DLTensor*)hc_scale)[0].data); + if ((((DLTensor*)hc_base)[0].ndim) != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_4; + result_4.type_index = kTVMFFINone; + result_4.zero_padding = 0; + result_4.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_4) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides = (((DLTensor*)hc_base)[0].strides); + void* hc_base_1 = (((DLTensor*)hc_base)[0].data); + if ((((DLTensor*)residual)[0].ndim) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_5; + result_5.type_index = kTVMFFINone; + result_5.zero_padding = 0; + result_5.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_5) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_residual_strides = (((DLTensor*)residual)[0].strides); + void* residual_1 = (((DLTensor*)residual)[0].data); + if ((((DLTensor*)post_mix)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_6; + result_6.type_index = kTVMFFINone; + result_6.zero_padding = 0; + result_6.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_6) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides = (((DLTensor*)post_mix)[0].strides); + void* post_mix_1 = (((DLTensor*)post_mix)[0].data); + if ((((DLTensor*)comb_mix)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_7; + result_7.type_index = kTVMFFINone; + result_7.zero_padding = 0; + result_7.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_7) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides = (((DLTensor*)comb_mix)[0].strides); + void* comb_mix_1 = (((DLTensor*)comb_mix)[0].data); + if ((((DLTensor*)layer_input)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_8; + result_8.type_index = kTVMFFINone; + result_8.zero_padding = 0; + result_8.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_8) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides = (((DLTensor*)layer_input)[0].strides); + void* layer_input_1 = (((DLTensor*)layer_input)[0].data); + if ((((DLTensor*)norm_weight)[0].ndim) != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_9; + result_9.type_index = kTVMFFINone; + result_9.zero_padding = 0; + result_9.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_9) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides = (((DLTensor*)norm_weight)[0].strides); + void* norm_weight_1 = (((DLTensor*)norm_weight)[0].data); + if ((((((DLTensor*)gemm_out_mul)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)gemm_out_mul)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)gemm_out_mul)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_10; + result_10.type_index = kTVMFFINone; + result_10.zero_padding = 0; + result_10.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_10) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[0]) != 11) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)11; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_11; + result_11.type_index = kTVMFFINone; + result_11.zero_padding = 0; + result_11.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_11) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[2]) != 24) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)24; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[2])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_12; + result_12.type_index = kTVMFFINone; + result_12.zero_padding = 0; + result_12.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_12) != 0) { + return -1; + } + } + int32_t condval; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval = 1; + } else { + condval = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[2]); + } + if (condval != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_1; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval_1 = 1; + } else { + condval_1 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[2]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_1); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_13; + result_13.type_index = kTVMFFINone; + result_13.zero_padding = 0; + result_13.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_13) != 0) { + return -1; + } + } + int32_t condval_2; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval_2 = 1; + } else { + condval_2 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[1]); + } + if ((condval_2 != 24) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_14; + result_14.type_index = kTVMFFINone; + result_14.zero_padding = 0; + result_14.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_14) != 0) { + return -1; + } + } + int32_t condval_3; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval_3 = 1; + } else { + condval_3 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[0]); + } + if (((num_tokens * 24) != condval_3) && (num_tokens != 0)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_15; + result_15.type_index = kTVMFFINone; + result_15.zero_padding = 0; + result_15.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_15) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)gemm_out_mul)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_16; + result_16.type_index = kTVMFFINone; + result_16.zero_padding = 0; + result_16.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_16) != 0) { + return -1; + } + } + if ((((DLTensor*)gemm_out_mul)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_17; + result_17.type_index = kTVMFFINone; + result_17.zero_padding = 0; + result_17.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_17) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (gemm_out_mul_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_18; + result_18.type_index = kTVMFFINone; + result_18.zero_padding = 0; + result_18.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_18) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)gemm_out_sqrsum)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)gemm_out_sqrsum)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)gemm_out_sqrsum)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_19; + result_19.type_index = kTVMFFINone; + result_19.zero_padding = 0; + result_19.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_19) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[0]) != 11) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)11; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_20; + result_20.type_index = kTVMFFINone; + result_20.zero_padding = 0; + result_20.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_20) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[1])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_21; + result_21.type_index = kTVMFFINone; + result_21.zero_padding = 0; + result_21.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_21) != 0) { + return -1; + } + } + int32_t condval_4; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides == NULL)) { + condval_4 = 1; + } else { + condval_4 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides)[1]); + } + if ((condval_4 != 1) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_22; + result_22.type_index = kTVMFFINone; + result_22.zero_padding = 0; + result_22.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_22) != 0) { + return -1; + } + } + int32_t condval_5; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides == NULL)) { + condval_5 = 1; + } else { + condval_5 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides)[0]); + } + if ((((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != condval_5) && (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != 0)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_23; + result_23.type_index = kTVMFFINone; + result_23.zero_padding = 0; + result_23.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_23) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)gemm_out_sqrsum)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_24; + result_24.type_index = kTVMFFINone; + result_24.zero_padding = 0; + result_24.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_24) != 0) { + return -1; + } + } + if ((((DLTensor*)gemm_out_sqrsum)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_25; + result_25.type_index = kTVMFFINone; + result_25.zero_padding = 0; + result_25.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_25) != 0) { + return -1; + } + } + if ((((DLTensor*)gemm_out_sqrsum)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_26; + result_26.type_index = kTVMFFINone; + result_26.zero_padding = 0; + result_26.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_26) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (gemm_out_sqrsum_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_27; + result_27.type_index = kTVMFFINone; + result_27.zero_padding = 0; + result_27.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_27) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)hc_scale)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)hc_scale)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)hc_scale)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_28; + result_28.type_index = kTVMFFINone; + result_28.zero_padding = 0; + result_28.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_28) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_shape)[0]) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_29; + result_29.type_index = kTVMFFINone; + result_29.zero_padding = 0; + result_29.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_29) != 0) { + return -1; + } + } + int32_t condval_6; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides == NULL)) { + condval_6 = 1; + } else { + condval_6 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides)[0]); + } + if (condval_6 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_7; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides == NULL)) { + condval_7 = 1; + } else { + condval_7 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides)[0]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_7); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_30; + result_30.type_index = kTVMFFINone; + result_30.zero_padding = 0; + result_30.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_30) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)hc_scale)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_31; + result_31.type_index = kTVMFFINone; + result_31.zero_padding = 0; + result_31.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_31) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_scale)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_32; + result_32.type_index = kTVMFFINone; + result_32.zero_padding = 0; + result_32.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_32) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_scale)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_33; + result_33.type_index = kTVMFFINone; + result_33.zero_padding = 0; + result_33.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_33) != 0) { + return -1; + } + } + if (hc_scale_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_34; + result_34.type_index = kTVMFFINone; + result_34.zero_padding = 0; + result_34.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_34) != 0) { + return -1; + } + } + if ((((((DLTensor*)hc_base)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)hc_base)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)hc_base)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_35; + result_35.type_index = kTVMFFINone; + result_35.zero_padding = 0; + result_35.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_35) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_shape)[0]) != 24) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)24; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_36; + result_36.type_index = kTVMFFINone; + result_36.zero_padding = 0; + result_36.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_36) != 0) { + return -1; + } + } + int32_t condval_8; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides == NULL)) { + condval_8 = 1; + } else { + condval_8 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides)[0]); + } + if (condval_8 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_9; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides == NULL)) { + condval_9 = 1; + } else { + condval_9 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides)[0]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_9); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_37; + result_37.type_index = kTVMFFINone; + result_37.zero_padding = 0; + result_37.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_37) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)hc_base)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_38; + result_38.type_index = kTVMFFINone; + result_38.zero_padding = 0; + result_38.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_38) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_base)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_39; + result_39.type_index = kTVMFFINone; + result_39.zero_padding = 0; + result_39.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_39) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_base)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_40; + result_40.type_index = kTVMFFINone; + result_40.zero_padding = 0; + result_40.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_40) != 0) { + return -1; + } + } + if (hc_base_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_41; + result_41.type_index = kTVMFFINone; + result_41.zero_padding = 0; + result_41.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_41) != 0) { + return -1; + } + } + if ((((((DLTensor*)residual)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)residual)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)residual)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)residual)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)residual)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_42; + result_42.type_index = kTVMFFINone; + result_42.zero_padding = 0; + result_42.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_42) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_43; + result_43.type_index = kTVMFFINone; + result_43.zero_padding = 0; + result_43.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_43) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[1]) != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_44; + result_44.type_index = kTVMFFINone; + result_44.zero_padding = 0; + result_44.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_44) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[2]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[2])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_45; + result_45.type_index = kTVMFFINone; + result_45.zero_padding = 0; + result_45.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_45) != 0) { + return -1; + } + } + int32_t condval_10; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_10 = 1; + } else { + condval_10 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[2]); + } + if (condval_10 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_11; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_11 = 1; + } else { + condval_11 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[2]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_11); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_46; + result_46.type_index = kTVMFFINone; + result_46.zero_padding = 0; + result_46.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_46) != 0) { + return -1; + } + } + int32_t condval_12; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_12 = 1; + } else { + condval_12 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[1]); + } + if (condval_12 != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_13; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_13 = 1; + } else { + condval_13 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_13); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_47; + result_47.type_index = kTVMFFINone; + result_47.zero_padding = 0; + result_47.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_47) != 0) { + return -1; + } + } + int32_t condval_14; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_14 = 1; + } else { + condval_14 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[0]); + } + if ((condval_14 != 16384) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_48; + result_48.type_index = kTVMFFINone; + result_48.zero_padding = 0; + result_48.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_48) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)residual)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_49; + result_49.type_index = kTVMFFINone; + result_49.zero_padding = 0; + result_49.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_49) != 0) { + return -1; + } + } + if ((((DLTensor*)residual)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)residual)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_50; + result_50.type_index = kTVMFFINone; + result_50.zero_padding = 0; + result_50.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_50) != 0) { + return -1; + } + } + if ((((DLTensor*)residual)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_51; + result_51.type_index = kTVMFFINone; + result_51.zero_padding = 0; + result_51.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_51) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (residual_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_52; + result_52.type_index = kTVMFFINone; + result_52.zero_padding = 0; + result_52.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_52) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)post_mix)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)post_mix)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)post_mix)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_53; + result_53.type_index = kTVMFFINone; + result_53.zero_padding = 0; + result_53.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_53) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_54; + result_54.type_index = kTVMFFINone; + result_54.zero_padding = 0; + result_54.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_54) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[1]) != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_55; + result_55.type_index = kTVMFFINone; + result_55.zero_padding = 0; + result_55.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_55) != 0) { + return -1; + } + } + int32_t condval_15; + if ((mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides == NULL)) { + condval_15 = 1; + } else { + condval_15 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides)[1]); + } + if (condval_15 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_16; + if ((mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides == NULL)) { + condval_16 = 1; + } else { + condval_16 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_16); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_56; + result_56.type_index = kTVMFFINone; + result_56.zero_padding = 0; + result_56.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_56) != 0) { + return -1; + } + } + int32_t condval_17; + if ((mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides == NULL)) { + condval_17 = 1; + } else { + condval_17 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides)[0]); + } + if ((condval_17 != 4) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_57; + result_57.type_index = kTVMFFINone; + result_57.zero_padding = 0; + result_57.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_57) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)post_mix)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_58; + result_58.type_index = kTVMFFINone; + result_58.zero_padding = 0; + result_58.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_58) != 0) { + return -1; + } + } + if ((((DLTensor*)post_mix)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_59; + result_59.type_index = kTVMFFINone; + result_59.zero_padding = 0; + result_59.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_59) != 0) { + return -1; + } + } + if ((((DLTensor*)post_mix)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_60; + result_60.type_index = kTVMFFINone; + result_60.zero_padding = 0; + result_60.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_60) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (post_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_61; + result_61.type_index = kTVMFFINone; + result_61.zero_padding = 0; + result_61.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_61) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)comb_mix)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)comb_mix)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)comb_mix)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_62; + result_62.type_index = kTVMFFINone; + result_62.zero_padding = 0; + result_62.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_62) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_63; + result_63.type_index = kTVMFFINone; + result_63.zero_padding = 0; + result_63.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_63) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[1]) != 16) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_64; + result_64.type_index = kTVMFFINone; + result_64.zero_padding = 0; + result_64.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_64) != 0) { + return -1; + } + } + int32_t condval_18; + if ((mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides == NULL)) { + condval_18 = 1; + } else { + condval_18 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides)[1]); + } + if (condval_18 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_19; + if ((mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides == NULL)) { + condval_19 = 1; + } else { + condval_19 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_19); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_65; + result_65.type_index = kTVMFFINone; + result_65.zero_padding = 0; + result_65.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_65) != 0) { + return -1; + } + } + int32_t condval_20; + if ((mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides == NULL)) { + condval_20 = 1; + } else { + condval_20 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides)[0]); + } + if ((condval_20 != 16) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_66; + result_66.type_index = kTVMFFINone; + result_66.zero_padding = 0; + result_66.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_66) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)comb_mix)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_67; + result_67.type_index = kTVMFFINone; + result_67.zero_padding = 0; + result_67.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_67) != 0) { + return -1; + } + } + if ((((DLTensor*)comb_mix)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_68; + result_68.type_index = kTVMFFINone; + result_68.zero_padding = 0; + result_68.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_68) != 0) { + return -1; + } + } + if ((((DLTensor*)comb_mix)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_69; + result_69.type_index = kTVMFFINone; + result_69.zero_padding = 0; + result_69.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_69) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (comb_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_70; + result_70.type_index = kTVMFFINone; + result_70.zero_padding = 0; + result_70.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_70) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)layer_input)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)layer_input)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)layer_input)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_71; + result_71.type_index = kTVMFFINone; + result_71.zero_padding = 0; + result_71.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_71) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_72; + result_72.type_index = kTVMFFINone; + result_72.zero_padding = 0; + result_72.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_72) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[1]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_73; + result_73.type_index = kTVMFFINone; + result_73.zero_padding = 0; + result_73.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_73) != 0) { + return -1; + } + } + int32_t condval_21; + if ((mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides == NULL)) { + condval_21 = 1; + } else { + condval_21 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides)[1]); + } + if (condval_21 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_22; + if ((mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides == NULL)) { + condval_22 = 1; + } else { + condval_22 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_22); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_74; + result_74.type_index = kTVMFFINone; + result_74.zero_padding = 0; + result_74.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_74) != 0) { + return -1; + } + } + int32_t condval_23; + if ((mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides == NULL)) { + condval_23 = 1; + } else { + condval_23 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides)[0]); + } + if ((condval_23 != 4096) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_75; + result_75.type_index = kTVMFFINone; + result_75.zero_padding = 0; + result_75.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_75) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)layer_input)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_76; + result_76.type_index = kTVMFFINone; + result_76.zero_padding = 0; + result_76.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_76) != 0) { + return -1; + } + } + if ((((DLTensor*)layer_input)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_77; + result_77.type_index = kTVMFFINone; + result_77.zero_padding = 0; + result_77.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_77) != 0) { + return -1; + } + } + if ((((DLTensor*)layer_input)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_78; + result_78.type_index = kTVMFFINone; + result_78.zero_padding = 0; + result_78.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_78) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (layer_input_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_79; + result_79.type_index = kTVMFFINone; + result_79.zero_padding = 0; + result_79.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_79) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)norm_weight)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)norm_weight)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)norm_weight)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_80; + result_80.type_index = kTVMFFINone; + result_80.zero_padding = 0; + result_80.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_80) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_shape)[0]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_81; + result_81.type_index = kTVMFFINone; + result_81.zero_padding = 0; + result_81.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_81) != 0) { + return -1; + } + } + int32_t condval_24; + if ((mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides == NULL)) { + condval_24 = 1; + } else { + condval_24 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides)[0]); + } + if (condval_24 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_25; + if ((mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides == NULL)) { + condval_25 = 1; + } else { + condval_25 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides)[0]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_25); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_82; + result_82.type_index = kTVMFFINone; + result_82.zero_padding = 0; + result_82.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_82) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)norm_weight)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_83; + result_83.type_index = kTVMFFINone; + result_83.zero_padding = 0; + result_83.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_83) != 0) { + return -1; + } + } + if ((((DLTensor*)norm_weight)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_84; + result_84.type_index = kTVMFFINone; + result_84.zero_padding = 0; + result_84.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_84) != 0) { + return -1; + } + } + if ((((DLTensor*)norm_weight)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_85; + result_85.type_index = kTVMFFINone; + result_85.zero_padding = 0; + result_85.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_85) != 0) { + return -1; + } + } + if (norm_weight_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_86; + result_86.type_index = kTVMFFINone; + result_86.zero_padding = 0; + result_86.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_86) != 0) { + return -1; + } + } + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = ((int64_t)2); + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = ((int64_t)dev_id); + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + if (__tvm_set_device_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_set_device", &__tvm_set_device_packed) != 0) { + return -1; + } + } + TVMFFIAny result_87; + result_87.type_index = kTVMFFINone; + result_87.zero_padding = 0; + result_87.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_set_device_packed, (TVMFFIAny*) stack_ffi_any, 2, &result_87) != 0) { + return -1; + } + if (comb_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = comb_mix_1; + if (gemm_out_mul_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = gemm_out_mul_1; + if (gemm_out_sqrsum_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = gemm_out_sqrsum_1; + if (hc_base_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_ptr) = hc_base_1; + if (hc_scale_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_ptr) = hc_scale_1; + if (layer_input_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_ptr) = layer_input_1; + if (norm_weight_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_ptr) = norm_weight_1; + if (post_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_ptr) = post_mix_1; + if (residual_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_ptr) = residual_1; + (((TVMFFIAny*)stack_ffi_any)[9].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[9].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[9].v_int64) = ((int64_t)num_tokens); + (((TVMFFIAny*)stack_ffi_any)[10].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[10].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[10].v_int64) = ((int64_t)num_tokens); + (((TVMFFIAny*)stack_ffi_any)[11].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[11].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[11].v_int64) = ((int64_t)96); + (((TVMFFIAny*)stack_ffi_any)[12].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[12].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[12].v_int64) = ((int64_t)1); + (((TVMFFIAny*)stack_ffi_any)[13].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[13].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[13].v_int64) = ((int64_t)1); + (((TVMFFIAny*)stack_ffi_any)[14].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[14].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[14].v_int64) = ((int64_t)29040); + (((TVMFFIAny*)stack_ffi_any)[15].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[15].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[15].v_int64) = (int64_t)0; + if (mhc_pre_big_fuse_with_norm_tilelang_kernel_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "mhc_pre_big_fuse_with_norm_tilelang_kernel", &mhc_pre_big_fuse_with_norm_tilelang_kernel_packed) != 0) { + return -1; + } + } + TVMFFIAny result_88; + result_88.type_index = kTVMFFINone; + result_88.zero_padding = 0; + result_88.v_int64 = 0; + if (TVMFFIFunctionCall(mhc_pre_big_fuse_with_norm_tilelang_kernel_packed, (TVMFFIAny*) stack_ffi_any, 15, &result_88) != 0) { + return -1; + } + return 0; +} + +// CodegenC: NOTE: Auto-generated entry function +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_main(void* self, void* args,int num_args, void* result) { + return __tvm_ffi_mhc_pre_big_fuse_with_norm_tilelang(self, args, num_args, result); +} diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/147eb04270024c36acaf2922c18e38bbdfc222673231f206ebd108766e937d6c/params.pkl b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/147eb04270024c36acaf2922c18e38bbdfc222673231f206ebd108766e937d6c/params.pkl new file mode 100644 index 0000000..4a4539c Binary files /dev/null and b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/147eb04270024c36acaf2922c18e38bbdfc222673231f206ebd108766e937d6c/params.pkl differ diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/1eae71a46e812d68441e1ebddd96e5dbecfaeec6b4f8ed7749c4f21be97720e8/device_kernel.cu b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/1eae71a46e812d68441e1ebddd96e5dbecfaeec6b4f8ed7749c4f21be97720e8/device_kernel.cu new file mode 100644 index 0000000..4678c70 --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/1eae71a46e812d68441e1ebddd96e5dbecfaeec6b4f8ed7749c4f21be97720e8/device_kernel.cu @@ -0,0 +1,424 @@ +#include +#include +#include +#include +#include +#include +#include +#ifdef ENABLE_BF16 +#include +#endif + +extern "C" __global__ void mhc_pre_big_fuse_with_norm_tilelang_kernel(float* comb_mix, const float* gemm_out_mul, const float* gemm_out_sqrsum, const float* hc_base, const float* hc_scale, bfloat16_t* layer_input, const bfloat16_t* norm_weight, float* post_mix, const bfloat16_t* residual, int num_tokens); +extern "C" __global__ void __launch_bounds__(96, 1) mhc_pre_big_fuse_with_norm_tilelang_kernel(float* comb_mix, const float* gemm_out_mul, const float* gemm_out_sqrsum, const float* hc_base, const float* hc_scale, bfloat16_t* layer_input, const bfloat16_t* norm_weight, float* post_mix, const bfloat16_t* residual, int num_tokens) { + extern __shared__ __align__(1024) uchar buf_dyn_shmem[]; + float mixes[1]; + float rms[1]; + float cm[1]; + float row_max[1]; + float row_sum[1]; + float col_sum[1]; + float sumsq_per_pos[16]; + float sumsq[1]; + float rsqrt_norm[1]; + float xl[64]; + float ol[16]; + bfloat16_t xs_local_cast[8]; + bfloat16_t xs_local_cast_1[8]; + bfloat16_t xs_local_cast_2[8]; + float w_local[16]; + float ol_1[16]; + bfloat16_t w_shared_local_cast_3[8]; + bfloat16_t output_shared_local_cast_4[8]; + bfloat16_t layer_input_local_cast_5[8]; + bfloat16_t w_shared_local_cast_6[8]; + bfloat16_t output_shared_local_cast_7[8]; + bfloat16_t layer_input_local_cast_8[8]; + bfloat16_t w_shared_local_cast_9[8]; + bfloat16_t output_shared_local_cast_10[8]; + bfloat16_t layer_input_local_cast_11[8]; + mixes[0] = 0x0p+0f/*0.000000e+00*/; + rms[0] = 0x0p+0f/*0.000000e+00*/; + cudaGridDependencySynchronize(); + for (int i_split = 0; i_split < 19; ++i_split) { + rms[0] = (rms[0] + gemm_out_sqrsum[((((int64_t)i_split) * ((int64_t)num_tokens)) + ((int64_t)((int)blockIdx.x)))]); + } + rms[0] = rsqrtf(((rms[0] / 0x1p+14f/*1.638400e+04*/) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + mixes[0] = 0x0p+0f/*0.000000e+00*/; + for (int i_split_1 = 0; i_split_1 < 19; ++i_split_1) { + mixes[0] = (mixes[0] + gemm_out_mul[(((((int64_t)((int)blockIdx.x)) * (int64_t)24) + ((((int64_t)i_split_1) * ((int64_t)num_tokens)) * (int64_t)24)) + (((int64_t)((int)threadIdx.x)) % (int64_t)24))]); + } + mixes[0] = (mixes[0] * rms[0]); + if ((((int)threadIdx.x) / 24) == 0) { + ((float*)buf_dyn_shmem)[(((int)threadIdx.x) % 24)] = mixes[0]; + } + __syncthreads(); + if (((int)threadIdx.x) < 32) { + if (((int)threadIdx.x) < 4) { + post_mix[((((int64_t)((int)blockIdx.x)) * (int64_t)4) + ((int64_t)((int)threadIdx.x)))] = ((0x1p+0f/*1.000000e+00*/ / (0x1p+0f/*1.000000e+00*/ + expf((0x0p+0f/*0.000000e+00*/ - ((((float*)buf_dyn_shmem)[(((int)threadIdx.x) + 4)] * hc_scale[1]) + hc_base[(((int)threadIdx.x) + 4)]))))) * 0x1p+1f/*2.000000e+00*/); + } + cm[0] = ((((float*)buf_dyn_shmem)[((((int)threadIdx.x) & 15) + 8)] * hc_scale[2]) + hc_base[((((int)threadIdx.x) & 15) + 8)]); + row_max[0] = -CUDART_INF_F; + row_max[0] = max(row_max[0], cm[0]); + row_max[0] = tl::AllReduce>::run(row_max[0]); + cm[0] = expf((cm[0] - row_max[0])); + row_sum[0] = 0x0p+0f/*0.000000e+00*/; + row_sum[0] = (row_sum[0] + cm[0]); + row_sum[0] = tl::AllReduce>::run(row_sum[0]); + cm[0] = ((cm[0] / row_sum[0]) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/); + col_sum[0] = 0x0p+0f/*0.000000e+00*/; + col_sum[0] = (col_sum[0] + cm[0]); + col_sum[0] = tl::AllReduce>::run(col_sum[0]); + cm[0] = (cm[0] / (col_sum[0] + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + for (int __1 = 0; __1 < 19; ++__1) { + row_sum[0] = 0x0p+0f/*0.000000e+00*/; + row_sum[0] = (row_sum[0] + cm[0]); + row_sum[0] = tl::AllReduce>::run(row_sum[0]); + cm[0] = (cm[0] / (row_sum[0] + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + col_sum[0] = 0x0p+0f/*0.000000e+00*/; + col_sum[0] = (col_sum[0] + cm[0]); + col_sum[0] = tl::AllReduce>::run(col_sum[0]); + cm[0] = (cm[0] / (col_sum[0] + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + } + if ((((int)threadIdx.x) >> 4) == 0) { + comb_mix[((((int64_t)((int)blockIdx.x)) * (int64_t)16) + (((int64_t)((int)threadIdx.x)) & (int64_t)15))] = cm[0]; + } + } else { + if (((int)threadIdx.x) < 36) { + ((float*)buf_dyn_shmem)[(((int)threadIdx.x) + 7224)] = ((0x1p+0f/*1.000000e+00*/ / (0x1p+0f/*1.000000e+00*/ + expf((0x0p+0f/*0.000000e+00*/ - ((((float*)buf_dyn_shmem)[(((int)threadIdx.x) - 32)] * hc_scale[0]) + hc_base[(((int)threadIdx.x) - 32)]))))) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/); + } + #pragma unroll + for (int i = 0; i < 4; ++i) { + float broadcast_var = 0x0p+0f/*0.000000e+00*/; + *(float4*)(sumsq_per_pos + (i * 4)) = make_float4(broadcast_var, broadcast_var, broadcast_var, broadcast_var); + } + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_1 = 0; i_1 < 8; ++i_1) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i_1 >> 1) * 1024) + (((((i_1 * 64) + ((int)threadIdx.x)) + 96) & 127) * 8)) + 48)])), (&(residual[(((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + ((((int64_t)i_1) >> (int64_t)1) * (int64_t)4096)) + (((((((int64_t)i_1) * (int64_t)64) + ((int64_t)((int)threadIdx.x))) + (int64_t)96) & (int64_t)127) * (int64_t)8))]))); + } + tl::cp_async_commit(); + #pragma unroll + for (int i_2 = 0; i_2 < 8; ++i_2) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i_2 >> 1) * 1024) + (((((i_2 * 64) + ((int)threadIdx.x)) + 96) & 127) * 8)) + 4144)])), (&(residual[((((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + ((((int64_t)i_2) >> (int64_t)1) * (int64_t)4096)) + (((((((int64_t)i_2) * (int64_t)64) + ((int64_t)((int)threadIdx.x))) + (int64_t)96) & (int64_t)127) * (int64_t)8)) + (int64_t)1024)]))); + } + tl::cp_async_commit(); + for (int i0_h = 0; i0_h < 2; ++i0_h) { + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_3 = 0; i_3 < 8; ++i_3) { + *(uint4*)(xs_local_cast + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + ((((i0_h * 4096) + (i_3 * 512)) + (((int)threadIdx.x) * 8)) - 208)); + for (int vec = 0; vec < 2; ++vec) { + float4 __2; + uint2 v_ = *(uint2*)(xs_local_cast + (vec * 4)); + ((float2*)(&__2))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v_))[0]); + ((float2*)(&__2))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v_))[1]); + *(float4*)(xl + ((i_3 * 8) + (vec * 4))) = __2; + } + } + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_4 = 0; i_4 < 8; ++i_4) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i0_h * 4096) + ((i_4 >> 1) * 1024)) + (((((i_4 * 64) + ((int)threadIdx.x)) + 96) & 127) * 8)) + 48)])), (&(residual[(((((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + ((((int64_t)i_4) >> (int64_t)1) * (int64_t)4096)) + (((int64_t)i0_h) * (int64_t)1024)) + (((((((int64_t)i_4) * (int64_t)64) + ((int64_t)((int)threadIdx.x))) + (int64_t)96) & (int64_t)127) * (int64_t)8)) + (int64_t)2048)]))); + } + tl::cp_async_commit(); + #pragma unroll + for (int i_5 = 0; i_5 < 4; ++i_5) { + float broadcast_var_1 = 0x0p+0f/*0.000000e+00*/; + *(float4*)(ol + (i_5 * 4)) = make_float4(broadcast_var_1, broadcast_var_1, broadcast_var_1, broadcast_var_1); + } + tl::__sync_thread_partial<3, 64>(); + for (int i_hc = 0; i_hc < 4; ++i_hc) { + float pre = ((float*)buf_dyn_shmem)[(i_hc + 7256)]; + #pragma unroll + for (int i_6 = 0; i_6 < 16; ++i_6) { + ol[i_6] = (ol[i_6] + (pre * xl[((i_hc * 16) + i_6)])); + } + } + #pragma unroll + for (int i_7 = 0; i_7 < 4; ++i_7) { + float4 __3; + float4 v__1 = *(float4*)(sumsq_per_pos + (i_7 * 4)); + float4 __4; + float4 v__2 = *(float4*)(ol + (i_7 * 4)); + __4.x = (v__2.x*v__2.x); + __4.y = (v__2.y*v__2.y); + __4.z = (v__2.z*v__2.z); + __4.w = (v__2.w*v__2.w); + __3.x = (v__1.x+__4.x); + __3.y = (v__1.y+__4.y); + __3.z = (v__1.z+__4.z); + __3.w = (v__1.w+__4.w); + *(float4*)(sumsq_per_pos + (i_7 * 4)) = __3; + uint2 __5; + float4 v__3 = *(float4*)(ol + (i_7 * 4)); + (reinterpret_cast<__nv_bfloat162*>(&__5))[0] = __float22bfloat162_rn(((float2*)(&v__3))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__5))[1] = __float22bfloat162_rn(((float2*)(&v__3))[1]); + *(uint2*)(((bfloat16_t*)buf_dyn_shmem) + (((((i0_h * 1024) + ((i_7 >> 1) * 512)) + (((int)threadIdx.x) * 8)) + ((i_7 & 1) * 4)) + 7984)) = __5; + } + } + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_8 = 0; i_8 < 8; ++i_8) { + *(uint4*)(xs_local_cast_1 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_8 * 512) + (((int)threadIdx.x) * 8)) - 208)); + for (int vec_1 = 0; vec_1 < 2; ++vec_1) { + float4 __6; + uint2 v__4 = *(uint2*)(xs_local_cast_1 + (vec_1 * 4)); + ((float2*)(&__6))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__4))[0]); + ((float2*)(&__6))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__4))[1]); + *(float4*)(xl + ((i_8 * 8) + (vec_1 * 4))) = __6; + } + } + #pragma unroll + for (int i_9 = 0; i_9 < 4; ++i_9) { + float broadcast_var_2 = 0x0p+0f/*0.000000e+00*/; + *(float4*)(ol + (i_9 * 4)) = make_float4(broadcast_var_2, broadcast_var_2, broadcast_var_2, broadcast_var_2); + } + for (int i_hc_1 = 0; i_hc_1 < 4; ++i_hc_1) { + float pre_1 = ((float*)buf_dyn_shmem)[(i_hc_1 + 7256)]; + #pragma unroll + for (int i_10 = 0; i_10 < 16; ++i_10) { + ol[i_10] = (ol[i_10] + (pre_1 * xl[((i_hc_1 * 16) + i_10)])); + } + } + #pragma unroll + for (int i_11 = 0; i_11 < 4; ++i_11) { + float4 __7; + float4 v__5 = *(float4*)(sumsq_per_pos + (i_11 * 4)); + float4 __8; + float4 v__6 = *(float4*)(ol + (i_11 * 4)); + __8.x = (v__6.x*v__6.x); + __8.y = (v__6.y*v__6.y); + __8.z = (v__6.z*v__6.z); + __8.w = (v__6.w*v__6.w); + __7.x = (v__5.x+__8.x); + __7.y = (v__5.y+__8.y); + __7.z = (v__5.z+__8.z); + __7.w = (v__5.w+__8.w); + *(float4*)(sumsq_per_pos + (i_11 * 4)) = __7; + uint2 __9; + float4 v__7 = *(float4*)(ol + (i_11 * 4)); + (reinterpret_cast<__nv_bfloat162*>(&__9))[0] = __float22bfloat162_rn(((float2*)(&v__7))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__9))[1] = __float22bfloat162_rn(((float2*)(&v__7))[1]); + *(uint2*)(((bfloat16_t*)buf_dyn_shmem) + (((((i_11 >> 1) * 512) + (((int)threadIdx.x) * 8)) + ((i_11 & 1) * 4)) + 10032)) = __9; + } + tl::cp_async_wait<0>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_12 = 0; i_12 < 8; ++i_12) { + *(uint4*)(xs_local_cast_2 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_12 * 512) + (((int)threadIdx.x) * 8)) + 3888)); + for (int vec_2 = 0; vec_2 < 2; ++vec_2) { + float4 __10; + uint2 v__8 = *(uint2*)(xs_local_cast_2 + (vec_2 * 4)); + ((float2*)(&__10))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__8))[0]); + ((float2*)(&__10))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__8))[1]); + *(float4*)(xl + ((i_12 * 8) + (vec_2 * 4))) = __10; + } + } + #pragma unroll + for (int i_13 = 0; i_13 < 4; ++i_13) { + float broadcast_var_3 = 0x0p+0f/*0.000000e+00*/; + *(float4*)(ol + (i_13 * 4)) = make_float4(broadcast_var_3, broadcast_var_3, broadcast_var_3, broadcast_var_3); + } + for (int i_hc_2 = 0; i_hc_2 < 4; ++i_hc_2) { + float pre_2 = ((float*)buf_dyn_shmem)[(i_hc_2 + 7256)]; + #pragma unroll + for (int i_14 = 0; i_14 < 16; ++i_14) { + ol[i_14] = (ol[i_14] + (pre_2 * xl[((i_hc_2 * 16) + i_14)])); + } + } + #pragma unroll + for (int i_15 = 0; i_15 < 4; ++i_15) { + float4 __11; + float4 v__9 = *(float4*)(sumsq_per_pos + (i_15 * 4)); + float4 __12; + float4 v__10 = *(float4*)(ol + (i_15 * 4)); + __12.x = (v__10.x*v__10.x); + __12.y = (v__10.y*v__10.y); + __12.z = (v__10.z*v__10.z); + __12.w = (v__10.w*v__10.w); + __11.x = (v__9.x+__12.x); + __11.y = (v__9.y+__12.y); + __11.z = (v__9.z+__12.z); + __11.w = (v__9.w+__12.w); + *(float4*)(sumsq_per_pos + (i_15 * 4)) = __11; + uint2 __13; + float4 v__11 = *(float4*)(ol + (i_15 * 4)); + (reinterpret_cast<__nv_bfloat162*>(&__13))[0] = __float22bfloat162_rn(((float2*)(&v__11))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__13))[1] = __float22bfloat162_rn(((float2*)(&v__11))[1]); + *(uint2*)(((bfloat16_t*)buf_dyn_shmem) + (((((i_15 >> 1) * 512) + (((int)threadIdx.x) * 8)) + ((i_15 & 1) * 4)) + 11056)) = __13; + } + sumsq[0] = 0x0p+0f/*0.000000e+00*/; + #pragma unroll + for (int rv = 0; rv < 16; ++rv) { + sumsq[0] = (sumsq[0] + sumsq_per_pos[(((rv & 1) * 8) + (rv >> 1))]); + } + tl::__sync_thread_partial<3, 64>(); + sumsq[0] = tl::AllReduce>::run(sumsq[0], (&(((float*)buf_dyn_shmem)[7192]))); + rsqrt_norm[0] = rsqrtf(((sumsq[0] / 0x1p+12f/*4.096000e+03*/) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + #pragma unroll + for (int i_16 = 0; i_16 < 2; ++i_16) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[(((i_16 * 512) + (((int)threadIdx.x) * 8)) + 12080)])), (&(norm_weight[(((i_16 * 512) + (((int)threadIdx.x) * 8)) - 256)]))); + } + tl::cp_async_commit(); + #pragma unroll + for (int i_17 = 0; i_17 < 2; ++i_17) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[(((i_17 * 512) + (((int)threadIdx.x) * 8)) + 13104)])), (&(norm_weight[(((i_17 * 512) + (((int)threadIdx.x) * 8)) + 768)]))); + } + tl::cp_async_commit(); + for (int i0_h_1 = 0; i0_h_1 < 2; ++i0_h_1) { + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_18 = 0; i_18 < 2; ++i_18) { + *(uint4*)(w_shared_local_cast_3 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + ((((i0_h_1 * 1024) + (i_18 * 512)) + (((int)threadIdx.x) * 8)) + 12080)); + for (int vec_3 = 0; vec_3 < 2; ++vec_3) { + float4 __14; + uint2 v__12 = *(uint2*)(w_shared_local_cast_3 + (vec_3 * 4)); + ((float2*)(&__14))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__12))[0]); + ((float2*)(&__14))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__12))[1]); + *(float4*)(w_local + ((i_18 * 8) + (vec_3 * 4))) = __14; + } + } + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_19 = 0; i_19 < 2; ++i_19) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i0_h_1 * 1024) + (i_19 * 512)) + (((int)threadIdx.x) * 8)) + 12080)])), (&(norm_weight[((((i0_h_1 * 1024) + (i_19 * 512)) + (((int)threadIdx.x) * 8)) + 1792)]))); + } + tl::cp_async_commit(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_20 = 0; i_20 < 2; ++i_20) { + *(uint4*)(output_shared_local_cast_4 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + ((((i0_h_1 * 1024) + (i_20 * 512)) + (((int)threadIdx.x) * 8)) + 7984)); + for (int vec_4 = 0; vec_4 < 2; ++vec_4) { + float4 __15; + float4 __16; + float4 __17; + uint2 v__13 = *(uint2*)(output_shared_local_cast_4 + (vec_4 * 4)); + ((float2*)(&__17))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__13))[0]); + ((float2*)(&__17))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__13))[1]); + float4 v__14 = make_float4(rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0]); + __16.x = (__17.x*v__14.x); + __16.y = (__17.y*v__14.y); + __16.z = (__17.z*v__14.z); + __16.w = (__17.w*v__14.w); + float4 v__15 = *(float4*)(w_local + ((i_20 * 8) + (vec_4 * 4))); + __15.x = (__16.x*v__15.x); + __15.y = (__16.y*v__15.y); + __15.z = (__16.z*v__15.z); + __15.w = (__16.w*v__15.w); + *(float4*)(ol_1 + ((i_20 * 8) + (vec_4 * 4))) = __15; + } + } + #pragma unroll + for (int i_21 = 0; i_21 < 2; ++i_21) { + for (int vec_5 = 0; vec_5 < 2; ++vec_5) { + uint2 __18; + float4 v__16 = *(float4*)(ol_1 + ((i_21 * 8) + (vec_5 * 4))); + (reinterpret_cast<__nv_bfloat162*>(&__18))[0] = __float22bfloat162_rn(((float2*)(&v__16))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__18))[1] = __float22bfloat162_rn(((float2*)(&v__16))[1]); + *(uint2*)(layer_input_local_cast_5 + (vec_5 * 4)) = __18; + } + *(uint4*)(layer_input + (((((((int64_t)((int)blockIdx.x)) * (int64_t)4096) + (((int64_t)i0_h_1) * (int64_t)1024)) + (((int64_t)i_21) * (int64_t)512)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8)) - (int64_t)256)) = *(uint4*)(layer_input_local_cast_5 + 0); + } + } + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_22 = 0; i_22 < 2; ++i_22) { + *(uint4*)(w_shared_local_cast_6 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_22 * 512) + (((int)threadIdx.x) * 8)) + 12080)); + for (int vec_6 = 0; vec_6 < 2; ++vec_6) { + float4 __19; + uint2 v__17 = *(uint2*)(w_shared_local_cast_6 + (vec_6 * 4)); + ((float2*)(&__19))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__17))[0]); + ((float2*)(&__19))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__17))[1]); + *(float4*)(w_local + ((i_22 * 8) + (vec_6 * 4))) = __19; + } + } + #pragma unroll + for (int i_23 = 0; i_23 < 2; ++i_23) { + *(uint4*)(output_shared_local_cast_7 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_23 * 512) + (((int)threadIdx.x) * 8)) + 10032)); + for (int vec_7 = 0; vec_7 < 2; ++vec_7) { + float4 __20; + float4 __21; + float4 __22; + uint2 v__18 = *(uint2*)(output_shared_local_cast_7 + (vec_7 * 4)); + ((float2*)(&__22))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__18))[0]); + ((float2*)(&__22))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__18))[1]); + float4 v__19 = make_float4(rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0]); + __21.x = (__22.x*v__19.x); + __21.y = (__22.y*v__19.y); + __21.z = (__22.z*v__19.z); + __21.w = (__22.w*v__19.w); + float4 v__20 = *(float4*)(w_local + ((i_23 * 8) + (vec_7 * 4))); + __20.x = (__21.x*v__20.x); + __20.y = (__21.y*v__20.y); + __20.z = (__21.z*v__20.z); + __20.w = (__21.w*v__20.w); + *(float4*)(ol_1 + ((i_23 * 8) + (vec_7 * 4))) = __20; + } + } + #pragma unroll + for (int i_24 = 0; i_24 < 2; ++i_24) { + for (int vec_8 = 0; vec_8 < 2; ++vec_8) { + uint2 __23; + float4 v__21 = *(float4*)(ol_1 + ((i_24 * 8) + (vec_8 * 4))); + (reinterpret_cast<__nv_bfloat162*>(&__23))[0] = __float22bfloat162_rn(((float2*)(&v__21))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__23))[1] = __float22bfloat162_rn(((float2*)(&v__21))[1]); + *(uint2*)(layer_input_local_cast_8 + (vec_8 * 4)) = __23; + } + *(uint4*)(layer_input + ((((((int64_t)((int)blockIdx.x)) * (int64_t)4096) + (((int64_t)i_24) * (int64_t)512)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8)) + (int64_t)1792)) = *(uint4*)(layer_input_local_cast_8 + 0); + } + tl::cp_async_wait<0>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_25 = 0; i_25 < 2; ++i_25) { + *(uint4*)(w_shared_local_cast_9 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_25 * 512) + (((int)threadIdx.x) * 8)) + 13104)); + for (int vec_9 = 0; vec_9 < 2; ++vec_9) { + float4 __24; + uint2 v__22 = *(uint2*)(w_shared_local_cast_9 + (vec_9 * 4)); + ((float2*)(&__24))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__22))[0]); + ((float2*)(&__24))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__22))[1]); + *(float4*)(w_local + ((i_25 * 8) + (vec_9 * 4))) = __24; + } + } + #pragma unroll + for (int i_26 = 0; i_26 < 2; ++i_26) { + *(uint4*)(output_shared_local_cast_10 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_26 * 512) + (((int)threadIdx.x) * 8)) + 11056)); + for (int vec_10 = 0; vec_10 < 2; ++vec_10) { + float4 __25; + float4 __26; + float4 __27; + uint2 v__23 = *(uint2*)(output_shared_local_cast_10 + (vec_10 * 4)); + ((float2*)(&__27))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__23))[0]); + ((float2*)(&__27))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__23))[1]); + float4 v__24 = make_float4(rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0]); + __26.x = (__27.x*v__24.x); + __26.y = (__27.y*v__24.y); + __26.z = (__27.z*v__24.z); + __26.w = (__27.w*v__24.w); + float4 v__25 = *(float4*)(w_local + ((i_26 * 8) + (vec_10 * 4))); + __25.x = (__26.x*v__25.x); + __25.y = (__26.y*v__25.y); + __25.z = (__26.z*v__25.z); + __25.w = (__26.w*v__25.w); + *(float4*)(ol_1 + ((i_26 * 8) + (vec_10 * 4))) = __25; + } + } + #pragma unroll + for (int i_27 = 0; i_27 < 2; ++i_27) { + for (int vec_11 = 0; vec_11 < 2; ++vec_11) { + uint2 __28; + float4 v__26 = *(float4*)(ol_1 + ((i_27 * 8) + (vec_11 * 4))); + (reinterpret_cast<__nv_bfloat162*>(&__28))[0] = __float22bfloat162_rn(((float2*)(&v__26))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__28))[1] = __float22bfloat162_rn(((float2*)(&v__26))[1]); + *(uint2*)(layer_input_local_cast_11 + (vec_11 * 4)) = __28; + } + *(uint4*)(layer_input + ((((((int64_t)((int)blockIdx.x)) * (int64_t)4096) + (((int64_t)i_27) * (int64_t)512)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8)) + (int64_t)2816)) = *(uint4*)(layer_input_local_cast_11 + 0); + } + } + cudaTriggerProgrammaticLaunchCompletion(); +} + diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/1eae71a46e812d68441e1ebddd96e5dbecfaeec6b4f8ed7749c4f21be97720e8/host_kernel.cu b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/1eae71a46e812d68441e1ebddd96e5dbecfaeec6b4f8ed7749c4f21be97720e8/host_kernel.cu new file mode 100644 index 0000000..1f028bd --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/1eae71a46e812d68441e1ebddd96e5dbecfaeec6b4f8ed7749c4f21be97720e8/host_kernel.cu @@ -0,0 +1,3359 @@ +// tilelang target: c -keys=cpu +#define TVM_EXPORTS +#include "tvm/runtime/base.h" +#include "tvm/runtime/c_backend_api.h" +#include "tvm/ffi/c_api.h" +#include +#include +#include +#ifdef __OBJC__ +#include "tvm/runtime/device_api.h" +#include "tvm/ffi/function.h" +#include +#include +#include +#endif +void* __tvm_ffi__library_ctx = NULL; +static void* __tvm_error_ndim_mismatch_packed = NULL; +static void* __tvm_error_dtype_mismatch_packed = NULL; +static void* __tvm_error_expect_eq_packed = NULL; +static void* __tvm_error_constraint_violation_packed = NULL; +static void* __tvm_error_byte_offset_mismatch_packed = NULL; +static void* __tvm_error_device_type_mismatch_packed = NULL; +static void* __tvm_error_null_ptr_packed = NULL; +static void* __tvm_set_device_packed = NULL; +static void* mhc_pre_big_fuse_with_norm_tilelang_kernel_packed = NULL; +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_mhc_pre_big_fuse_with_norm_tilelang(void* self_handle, void* args, int32_t num_args, void* result); +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_mhc_pre_big_fuse_with_norm_tilelang(void* self_handle, void* args, int32_t num_args, void* result) { + __attribute__((aligned(64))) TVMFFIAny stack[16]; + void* stack_ffi_any = stack; + if (!((num_args == 9))) { + char __tvm_assert_msg_buf[512]; + snprintf(__tvm_assert_msg_buf, 512, "%s; expected: %lld, got: %lld", "mhc_pre_big_fuse_with_norm_tilelang: num_args should be 9", (long long)(num_args), (long long)(9)); + TVMFFIErrorSetRaisedFromCStr("RuntimeError", __tvm_assert_msg_buf); + return -1; + } + if (!(!(args == NULL))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang: args pointer is NULL"); + return -1; + } + int32_t gemm_out_mul_type_index = (((TVMFFIAny*)args)[0].type_index); + if (!(((((gemm_out_mul_type_index == 0) || (gemm_out_mul_type_index == 4)) || (gemm_out_mul_type_index == 7)) || (64 <= gemm_out_mul_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input gemm_out_mul expected pointer or tensor handle"); + return -1; + } + int32_t gemm_out_sqrsum_type_index = (((TVMFFIAny*)args)[1].type_index); + if (!(((((gemm_out_sqrsum_type_index == 0) || (gemm_out_sqrsum_type_index == 4)) || (gemm_out_sqrsum_type_index == 7)) || (64 <= gemm_out_sqrsum_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input gemm_out_sqrsum expected pointer or tensor handle"); + return -1; + } + int32_t hc_scale_type_index = (((TVMFFIAny*)args)[2].type_index); + if (!(((((hc_scale_type_index == 0) || (hc_scale_type_index == 4)) || (hc_scale_type_index == 7)) || (64 <= hc_scale_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input hc_scale expected pointer or tensor handle"); + return -1; + } + int32_t hc_base_type_index = (((TVMFFIAny*)args)[3].type_index); + if (!(((((hc_base_type_index == 0) || (hc_base_type_index == 4)) || (hc_base_type_index == 7)) || (64 <= hc_base_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input hc_base expected pointer or tensor handle"); + return -1; + } + int32_t residual_type_index = (((TVMFFIAny*)args)[4].type_index); + if (!(((((residual_type_index == 0) || (residual_type_index == 4)) || (residual_type_index == 7)) || (64 <= residual_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input residual expected pointer or tensor handle"); + return -1; + } + int32_t post_mix_type_index = (((TVMFFIAny*)args)[5].type_index); + if (!(((((post_mix_type_index == 0) || (post_mix_type_index == 4)) || (post_mix_type_index == 7)) || (64 <= post_mix_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input post_mix expected pointer or tensor handle"); + return -1; + } + int32_t comb_mix_type_index = (((TVMFFIAny*)args)[6].type_index); + if (!(((((comb_mix_type_index == 0) || (comb_mix_type_index == 4)) || (comb_mix_type_index == 7)) || (64 <= comb_mix_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input comb_mix expected pointer or tensor handle"); + return -1; + } + int32_t layer_input_type_index = (((TVMFFIAny*)args)[7].type_index); + if (!(((((layer_input_type_index == 0) || (layer_input_type_index == 4)) || (layer_input_type_index == 7)) || (64 <= layer_input_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input layer_input expected pointer or tensor handle"); + return -1; + } + int32_t norm_weight_type_index = (((TVMFFIAny*)args)[8].type_index); + if (!(((((norm_weight_type_index == 0) || (norm_weight_type_index == 4)) || (norm_weight_type_index == 7)) || (64 <= norm_weight_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input norm_weight expected pointer or tensor handle"); + return -1; + } + void* gemm_out_mul = ((gemm_out_mul_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[0].v_ptr) + 24)) : (((TVMFFIAny*)args)[0].v_ptr)); + void* gemm_out_sqrsum = ((gemm_out_sqrsum_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[1].v_ptr) + 24)) : (((TVMFFIAny*)args)[1].v_ptr)); + void* hc_scale = ((hc_scale_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[2].v_ptr) + 24)) : (((TVMFFIAny*)args)[2].v_ptr)); + void* hc_base = ((hc_base_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[3].v_ptr) + 24)) : (((TVMFFIAny*)args)[3].v_ptr)); + void* residual = ((residual_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[4].v_ptr) + 24)) : (((TVMFFIAny*)args)[4].v_ptr)); + void* post_mix = ((post_mix_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[5].v_ptr) + 24)) : (((TVMFFIAny*)args)[5].v_ptr)); + void* comb_mix = ((comb_mix_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[6].v_ptr) + 24)) : (((TVMFFIAny*)args)[6].v_ptr)); + void* layer_input = ((layer_input_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[7].v_ptr) + 24)) : (((TVMFFIAny*)args)[7].v_ptr)); + void* norm_weight = ((norm_weight_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[8].v_ptr) + 24)) : (((TVMFFIAny*)args)[8].v_ptr)); + bool mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_is_null = (gemm_out_mul == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.gemm_out_mul is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_is_null = (gemm_out_sqrsum == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.gemm_out_sqrsum is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_hc_scale_is_null = (hc_scale == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_hc_scale_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.hc_scale is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_hc_base_is_null = (hc_base == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_hc_base_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.hc_base is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_residual_is_null = (residual == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_residual_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.residual is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_post_mix_is_null = (post_mix == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_post_mix_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.post_mix is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_comb_mix_is_null = (comb_mix == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_comb_mix_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.comb_mix is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_layer_input_is_null = (layer_input == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_layer_input_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.layer_input is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_norm_weight_is_null = (norm_weight == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_norm_weight_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.norm_weight is expected to have non-NULL pointer"); + return -1; + } + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape = (((DLTensor*)gemm_out_mul)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape = (((DLTensor*)gemm_out_sqrsum)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_hc_scale_shape = (((DLTensor*)hc_scale)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_hc_base_shape = (((DLTensor*)hc_base)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_residual_shape = (((DLTensor*)residual)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape = (((DLTensor*)post_mix)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape = (((DLTensor*)comb_mix)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape = (((DLTensor*)layer_input)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_norm_weight_shape = (((DLTensor*)norm_weight)[0].shape); + if ((((DLTensor*)gemm_out_mul)[0].ndim) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_1; + result_1.type_index = kTVMFFINone; + result_1.zero_padding = 0; + result_1.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_1) != 0) { + return -1; + } + } + if (!((bool)1)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "Symbolic shape variable num_tokens requires at least one non-null buffer among: mhc_pre_big_fuse_with_norm_tilelang.gemm_out_mul, mhc_pre_big_fuse_with_norm_tilelang.gemm_out_sqrsum, mhc_pre_big_fuse_with_norm_tilelang.residual, mhc_pre_big_fuse_with_norm_tilelang.post_mix, mhc_pre_big_fuse_with_norm_tilelang.comb_mix, mhc_pre_big_fuse_with_norm_tilelang.layer_input"); + return -1; + } + int32_t num_tokens = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]); + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides = (((DLTensor*)gemm_out_mul)[0].strides); + int32_t dev_id = (((DLTensor*)gemm_out_mul)[0].device.device_id); + void* gemm_out_mul_1 = (((DLTensor*)gemm_out_mul)[0].data); + if ((((DLTensor*)gemm_out_sqrsum)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_2; + result_2.type_index = kTVMFFINone; + result_2.zero_padding = 0; + result_2.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_2) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides = (((DLTensor*)gemm_out_sqrsum)[0].strides); + void* gemm_out_sqrsum_1 = (((DLTensor*)gemm_out_sqrsum)[0].data); + if ((((DLTensor*)hc_scale)[0].ndim) != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_3; + result_3.type_index = kTVMFFINone; + result_3.zero_padding = 0; + result_3.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_3) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides = (((DLTensor*)hc_scale)[0].strides); + void* hc_scale_1 = (((DLTensor*)hc_scale)[0].data); + if ((((DLTensor*)hc_base)[0].ndim) != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_4; + result_4.type_index = kTVMFFINone; + result_4.zero_padding = 0; + result_4.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_4) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides = (((DLTensor*)hc_base)[0].strides); + void* hc_base_1 = (((DLTensor*)hc_base)[0].data); + if ((((DLTensor*)residual)[0].ndim) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_5; + result_5.type_index = kTVMFFINone; + result_5.zero_padding = 0; + result_5.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_5) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_residual_strides = (((DLTensor*)residual)[0].strides); + void* residual_1 = (((DLTensor*)residual)[0].data); + if ((((DLTensor*)post_mix)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_6; + result_6.type_index = kTVMFFINone; + result_6.zero_padding = 0; + result_6.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_6) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides = (((DLTensor*)post_mix)[0].strides); + void* post_mix_1 = (((DLTensor*)post_mix)[0].data); + if ((((DLTensor*)comb_mix)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_7; + result_7.type_index = kTVMFFINone; + result_7.zero_padding = 0; + result_7.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_7) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides = (((DLTensor*)comb_mix)[0].strides); + void* comb_mix_1 = (((DLTensor*)comb_mix)[0].data); + if ((((DLTensor*)layer_input)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_8; + result_8.type_index = kTVMFFINone; + result_8.zero_padding = 0; + result_8.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_8) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides = (((DLTensor*)layer_input)[0].strides); + void* layer_input_1 = (((DLTensor*)layer_input)[0].data); + if ((((DLTensor*)norm_weight)[0].ndim) != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_9; + result_9.type_index = kTVMFFINone; + result_9.zero_padding = 0; + result_9.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_9) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides = (((DLTensor*)norm_weight)[0].strides); + void* norm_weight_1 = (((DLTensor*)norm_weight)[0].data); + if ((((((DLTensor*)gemm_out_mul)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)gemm_out_mul)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)gemm_out_mul)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_10; + result_10.type_index = kTVMFFINone; + result_10.zero_padding = 0; + result_10.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_10) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[0]) != 19) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)19; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_11; + result_11.type_index = kTVMFFINone; + result_11.zero_padding = 0; + result_11.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_11) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[2]) != 24) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)24; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[2])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_12; + result_12.type_index = kTVMFFINone; + result_12.zero_padding = 0; + result_12.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_12) != 0) { + return -1; + } + } + int32_t condval; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval = 1; + } else { + condval = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[2]); + } + if (condval != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_1; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval_1 = 1; + } else { + condval_1 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[2]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_1); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_13; + result_13.type_index = kTVMFFINone; + result_13.zero_padding = 0; + result_13.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_13) != 0) { + return -1; + } + } + int32_t condval_2; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval_2 = 1; + } else { + condval_2 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[1]); + } + if ((condval_2 != 24) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_14; + result_14.type_index = kTVMFFINone; + result_14.zero_padding = 0; + result_14.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_14) != 0) { + return -1; + } + } + int32_t condval_3; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval_3 = 1; + } else { + condval_3 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[0]); + } + if (((num_tokens * 24) != condval_3) && (num_tokens != 0)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_15; + result_15.type_index = kTVMFFINone; + result_15.zero_padding = 0; + result_15.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_15) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)gemm_out_mul)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_16; + result_16.type_index = kTVMFFINone; + result_16.zero_padding = 0; + result_16.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_16) != 0) { + return -1; + } + } + if ((((DLTensor*)gemm_out_mul)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_17; + result_17.type_index = kTVMFFINone; + result_17.zero_padding = 0; + result_17.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_17) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (gemm_out_mul_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_18; + result_18.type_index = kTVMFFINone; + result_18.zero_padding = 0; + result_18.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_18) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)gemm_out_sqrsum)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)gemm_out_sqrsum)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)gemm_out_sqrsum)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_19; + result_19.type_index = kTVMFFINone; + result_19.zero_padding = 0; + result_19.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_19) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[0]) != 19) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)19; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_20; + result_20.type_index = kTVMFFINone; + result_20.zero_padding = 0; + result_20.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_20) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[1])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_21; + result_21.type_index = kTVMFFINone; + result_21.zero_padding = 0; + result_21.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_21) != 0) { + return -1; + } + } + int32_t condval_4; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides == NULL)) { + condval_4 = 1; + } else { + condval_4 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides)[1]); + } + if ((condval_4 != 1) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_22; + result_22.type_index = kTVMFFINone; + result_22.zero_padding = 0; + result_22.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_22) != 0) { + return -1; + } + } + int32_t condval_5; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides == NULL)) { + condval_5 = 1; + } else { + condval_5 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides)[0]); + } + if ((((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != condval_5) && (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != 0)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_23; + result_23.type_index = kTVMFFINone; + result_23.zero_padding = 0; + result_23.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_23) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)gemm_out_sqrsum)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_24; + result_24.type_index = kTVMFFINone; + result_24.zero_padding = 0; + result_24.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_24) != 0) { + return -1; + } + } + if ((((DLTensor*)gemm_out_sqrsum)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_25; + result_25.type_index = kTVMFFINone; + result_25.zero_padding = 0; + result_25.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_25) != 0) { + return -1; + } + } + if ((((DLTensor*)gemm_out_sqrsum)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_26; + result_26.type_index = kTVMFFINone; + result_26.zero_padding = 0; + result_26.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_26) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (gemm_out_sqrsum_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_27; + result_27.type_index = kTVMFFINone; + result_27.zero_padding = 0; + result_27.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_27) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)hc_scale)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)hc_scale)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)hc_scale)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_28; + result_28.type_index = kTVMFFINone; + result_28.zero_padding = 0; + result_28.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_28) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_shape)[0]) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_29; + result_29.type_index = kTVMFFINone; + result_29.zero_padding = 0; + result_29.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_29) != 0) { + return -1; + } + } + int32_t condval_6; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides == NULL)) { + condval_6 = 1; + } else { + condval_6 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides)[0]); + } + if (condval_6 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_7; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides == NULL)) { + condval_7 = 1; + } else { + condval_7 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides)[0]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_7); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_30; + result_30.type_index = kTVMFFINone; + result_30.zero_padding = 0; + result_30.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_30) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)hc_scale)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_31; + result_31.type_index = kTVMFFINone; + result_31.zero_padding = 0; + result_31.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_31) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_scale)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_32; + result_32.type_index = kTVMFFINone; + result_32.zero_padding = 0; + result_32.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_32) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_scale)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_33; + result_33.type_index = kTVMFFINone; + result_33.zero_padding = 0; + result_33.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_33) != 0) { + return -1; + } + } + if (hc_scale_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_34; + result_34.type_index = kTVMFFINone; + result_34.zero_padding = 0; + result_34.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_34) != 0) { + return -1; + } + } + if ((((((DLTensor*)hc_base)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)hc_base)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)hc_base)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_35; + result_35.type_index = kTVMFFINone; + result_35.zero_padding = 0; + result_35.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_35) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_shape)[0]) != 24) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)24; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_36; + result_36.type_index = kTVMFFINone; + result_36.zero_padding = 0; + result_36.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_36) != 0) { + return -1; + } + } + int32_t condval_8; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides == NULL)) { + condval_8 = 1; + } else { + condval_8 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides)[0]); + } + if (condval_8 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_9; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides == NULL)) { + condval_9 = 1; + } else { + condval_9 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides)[0]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_9); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_37; + result_37.type_index = kTVMFFINone; + result_37.zero_padding = 0; + result_37.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_37) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)hc_base)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_38; + result_38.type_index = kTVMFFINone; + result_38.zero_padding = 0; + result_38.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_38) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_base)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_39; + result_39.type_index = kTVMFFINone; + result_39.zero_padding = 0; + result_39.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_39) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_base)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_40; + result_40.type_index = kTVMFFINone; + result_40.zero_padding = 0; + result_40.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_40) != 0) { + return -1; + } + } + if (hc_base_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_41; + result_41.type_index = kTVMFFINone; + result_41.zero_padding = 0; + result_41.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_41) != 0) { + return -1; + } + } + if ((((((DLTensor*)residual)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)residual)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)residual)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)residual)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)residual)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_42; + result_42.type_index = kTVMFFINone; + result_42.zero_padding = 0; + result_42.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_42) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_43; + result_43.type_index = kTVMFFINone; + result_43.zero_padding = 0; + result_43.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_43) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[1]) != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_44; + result_44.type_index = kTVMFFINone; + result_44.zero_padding = 0; + result_44.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_44) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[2]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[2])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_45; + result_45.type_index = kTVMFFINone; + result_45.zero_padding = 0; + result_45.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_45) != 0) { + return -1; + } + } + int32_t condval_10; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_10 = 1; + } else { + condval_10 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[2]); + } + if (condval_10 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_11; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_11 = 1; + } else { + condval_11 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[2]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_11); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_46; + result_46.type_index = kTVMFFINone; + result_46.zero_padding = 0; + result_46.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_46) != 0) { + return -1; + } + } + int32_t condval_12; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_12 = 1; + } else { + condval_12 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[1]); + } + if (condval_12 != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_13; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_13 = 1; + } else { + condval_13 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_13); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_47; + result_47.type_index = kTVMFFINone; + result_47.zero_padding = 0; + result_47.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_47) != 0) { + return -1; + } + } + int32_t condval_14; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_14 = 1; + } else { + condval_14 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[0]); + } + if ((condval_14 != 16384) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_48; + result_48.type_index = kTVMFFINone; + result_48.zero_padding = 0; + result_48.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_48) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)residual)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_49; + result_49.type_index = kTVMFFINone; + result_49.zero_padding = 0; + result_49.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_49) != 0) { + return -1; + } + } + if ((((DLTensor*)residual)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)residual)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_50; + result_50.type_index = kTVMFFINone; + result_50.zero_padding = 0; + result_50.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_50) != 0) { + return -1; + } + } + if ((((DLTensor*)residual)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_51; + result_51.type_index = kTVMFFINone; + result_51.zero_padding = 0; + result_51.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_51) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (residual_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_52; + result_52.type_index = kTVMFFINone; + result_52.zero_padding = 0; + result_52.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_52) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)post_mix)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)post_mix)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)post_mix)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_53; + result_53.type_index = kTVMFFINone; + result_53.zero_padding = 0; + result_53.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_53) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_54; + result_54.type_index = kTVMFFINone; + result_54.zero_padding = 0; + result_54.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_54) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[1]) != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_55; + result_55.type_index = kTVMFFINone; + result_55.zero_padding = 0; + result_55.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_55) != 0) { + return -1; + } + } + int32_t condval_15; + if ((mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides == NULL)) { + condval_15 = 1; + } else { + condval_15 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides)[1]); + } + if (condval_15 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_16; + if ((mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides == NULL)) { + condval_16 = 1; + } else { + condval_16 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_16); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_56; + result_56.type_index = kTVMFFINone; + result_56.zero_padding = 0; + result_56.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_56) != 0) { + return -1; + } + } + int32_t condval_17; + if ((mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides == NULL)) { + condval_17 = 1; + } else { + condval_17 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides)[0]); + } + if ((condval_17 != 4) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_57; + result_57.type_index = kTVMFFINone; + result_57.zero_padding = 0; + result_57.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_57) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)post_mix)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_58; + result_58.type_index = kTVMFFINone; + result_58.zero_padding = 0; + result_58.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_58) != 0) { + return -1; + } + } + if ((((DLTensor*)post_mix)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_59; + result_59.type_index = kTVMFFINone; + result_59.zero_padding = 0; + result_59.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_59) != 0) { + return -1; + } + } + if ((((DLTensor*)post_mix)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_60; + result_60.type_index = kTVMFFINone; + result_60.zero_padding = 0; + result_60.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_60) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (post_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_61; + result_61.type_index = kTVMFFINone; + result_61.zero_padding = 0; + result_61.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_61) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)comb_mix)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)comb_mix)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)comb_mix)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_62; + result_62.type_index = kTVMFFINone; + result_62.zero_padding = 0; + result_62.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_62) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_63; + result_63.type_index = kTVMFFINone; + result_63.zero_padding = 0; + result_63.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_63) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[1]) != 16) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_64; + result_64.type_index = kTVMFFINone; + result_64.zero_padding = 0; + result_64.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_64) != 0) { + return -1; + } + } + int32_t condval_18; + if ((mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides == NULL)) { + condval_18 = 1; + } else { + condval_18 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides)[1]); + } + if (condval_18 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_19; + if ((mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides == NULL)) { + condval_19 = 1; + } else { + condval_19 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_19); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_65; + result_65.type_index = kTVMFFINone; + result_65.zero_padding = 0; + result_65.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_65) != 0) { + return -1; + } + } + int32_t condval_20; + if ((mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides == NULL)) { + condval_20 = 1; + } else { + condval_20 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides)[0]); + } + if ((condval_20 != 16) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_66; + result_66.type_index = kTVMFFINone; + result_66.zero_padding = 0; + result_66.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_66) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)comb_mix)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_67; + result_67.type_index = kTVMFFINone; + result_67.zero_padding = 0; + result_67.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_67) != 0) { + return -1; + } + } + if ((((DLTensor*)comb_mix)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_68; + result_68.type_index = kTVMFFINone; + result_68.zero_padding = 0; + result_68.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_68) != 0) { + return -1; + } + } + if ((((DLTensor*)comb_mix)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_69; + result_69.type_index = kTVMFFINone; + result_69.zero_padding = 0; + result_69.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_69) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (comb_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_70; + result_70.type_index = kTVMFFINone; + result_70.zero_padding = 0; + result_70.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_70) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)layer_input)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)layer_input)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)layer_input)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_71; + result_71.type_index = kTVMFFINone; + result_71.zero_padding = 0; + result_71.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_71) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_72; + result_72.type_index = kTVMFFINone; + result_72.zero_padding = 0; + result_72.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_72) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[1]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_73; + result_73.type_index = kTVMFFINone; + result_73.zero_padding = 0; + result_73.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_73) != 0) { + return -1; + } + } + int32_t condval_21; + if ((mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides == NULL)) { + condval_21 = 1; + } else { + condval_21 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides)[1]); + } + if (condval_21 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_22; + if ((mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides == NULL)) { + condval_22 = 1; + } else { + condval_22 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_22); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_74; + result_74.type_index = kTVMFFINone; + result_74.zero_padding = 0; + result_74.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_74) != 0) { + return -1; + } + } + int32_t condval_23; + if ((mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides == NULL)) { + condval_23 = 1; + } else { + condval_23 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides)[0]); + } + if ((condval_23 != 4096) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_75; + result_75.type_index = kTVMFFINone; + result_75.zero_padding = 0; + result_75.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_75) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)layer_input)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_76; + result_76.type_index = kTVMFFINone; + result_76.zero_padding = 0; + result_76.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_76) != 0) { + return -1; + } + } + if ((((DLTensor*)layer_input)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_77; + result_77.type_index = kTVMFFINone; + result_77.zero_padding = 0; + result_77.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_77) != 0) { + return -1; + } + } + if ((((DLTensor*)layer_input)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_78; + result_78.type_index = kTVMFFINone; + result_78.zero_padding = 0; + result_78.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_78) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (layer_input_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_79; + result_79.type_index = kTVMFFINone; + result_79.zero_padding = 0; + result_79.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_79) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)norm_weight)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)norm_weight)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)norm_weight)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_80; + result_80.type_index = kTVMFFINone; + result_80.zero_padding = 0; + result_80.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_80) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_shape)[0]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_81; + result_81.type_index = kTVMFFINone; + result_81.zero_padding = 0; + result_81.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_81) != 0) { + return -1; + } + } + int32_t condval_24; + if ((mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides == NULL)) { + condval_24 = 1; + } else { + condval_24 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides)[0]); + } + if (condval_24 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_25; + if ((mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides == NULL)) { + condval_25 = 1; + } else { + condval_25 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides)[0]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_25); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_82; + result_82.type_index = kTVMFFINone; + result_82.zero_padding = 0; + result_82.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_82) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)norm_weight)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_83; + result_83.type_index = kTVMFFINone; + result_83.zero_padding = 0; + result_83.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_83) != 0) { + return -1; + } + } + if ((((DLTensor*)norm_weight)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_84; + result_84.type_index = kTVMFFINone; + result_84.zero_padding = 0; + result_84.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_84) != 0) { + return -1; + } + } + if ((((DLTensor*)norm_weight)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_85; + result_85.type_index = kTVMFFINone; + result_85.zero_padding = 0; + result_85.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_85) != 0) { + return -1; + } + } + if (norm_weight_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_86; + result_86.type_index = kTVMFFINone; + result_86.zero_padding = 0; + result_86.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_86) != 0) { + return -1; + } + } + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = ((int64_t)2); + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = ((int64_t)dev_id); + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + if (__tvm_set_device_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_set_device", &__tvm_set_device_packed) != 0) { + return -1; + } + } + TVMFFIAny result_87; + result_87.type_index = kTVMFFINone; + result_87.zero_padding = 0; + result_87.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_set_device_packed, (TVMFFIAny*) stack_ffi_any, 2, &result_87) != 0) { + return -1; + } + if (comb_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = comb_mix_1; + if (gemm_out_mul_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = gemm_out_mul_1; + if (gemm_out_sqrsum_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = gemm_out_sqrsum_1; + if (hc_base_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_ptr) = hc_base_1; + if (hc_scale_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_ptr) = hc_scale_1; + if (layer_input_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_ptr) = layer_input_1; + if (norm_weight_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_ptr) = norm_weight_1; + if (post_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_ptr) = post_mix_1; + if (residual_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_ptr) = residual_1; + (((TVMFFIAny*)stack_ffi_any)[9].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[9].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[9].v_int64) = ((int64_t)num_tokens); + (((TVMFFIAny*)stack_ffi_any)[10].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[10].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[10].v_int64) = ((int64_t)num_tokens); + (((TVMFFIAny*)stack_ffi_any)[11].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[11].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[11].v_int64) = ((int64_t)96); + (((TVMFFIAny*)stack_ffi_any)[12].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[12].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[12].v_int64) = ((int64_t)1); + (((TVMFFIAny*)stack_ffi_any)[13].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[13].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[13].v_int64) = ((int64_t)1); + (((TVMFFIAny*)stack_ffi_any)[14].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[14].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[14].v_int64) = ((int64_t)29040); + (((TVMFFIAny*)stack_ffi_any)[15].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[15].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[15].v_int64) = (int64_t)0; + if (mhc_pre_big_fuse_with_norm_tilelang_kernel_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "mhc_pre_big_fuse_with_norm_tilelang_kernel", &mhc_pre_big_fuse_with_norm_tilelang_kernel_packed) != 0) { + return -1; + } + } + TVMFFIAny result_88; + result_88.type_index = kTVMFFINone; + result_88.zero_padding = 0; + result_88.v_int64 = 0; + if (TVMFFIFunctionCall(mhc_pre_big_fuse_with_norm_tilelang_kernel_packed, (TVMFFIAny*) stack_ffi_any, 15, &result_88) != 0) { + return -1; + } + return 0; +} + +// CodegenC: NOTE: Auto-generated entry function +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_main(void* self, void* args,int num_args, void* result) { + return __tvm_ffi_mhc_pre_big_fuse_with_norm_tilelang(self, args, num_args, result); +} diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/1eae71a46e812d68441e1ebddd96e5dbecfaeec6b4f8ed7749c4f21be97720e8/params.pkl b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/1eae71a46e812d68441e1ebddd96e5dbecfaeec6b4f8ed7749c4f21be97720e8/params.pkl new file mode 100644 index 0000000..65b203c Binary files /dev/null and b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/1eae71a46e812d68441e1ebddd96e5dbecfaeec6b4f8ed7749c4f21be97720e8/params.pkl differ diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/1f417b351704372ae9697b314cec4913d9e69469d246e2c9d2c8400a16396625/device_kernel.cu b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/1f417b351704372ae9697b314cec4913d9e69469d246e2c9d2c8400a16396625/device_kernel.cu new file mode 100644 index 0000000..251cc64 --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/1f417b351704372ae9697b314cec4913d9e69469d246e2c9d2c8400a16396625/device_kernel.cu @@ -0,0 +1,424 @@ +#include +#include +#include +#include +#include +#include +#include +#ifdef ENABLE_BF16 +#include +#endif + +extern "C" __global__ void mhc_pre_big_fuse_with_norm_tilelang_kernel(float* comb_mix, const float* gemm_out_mul, const float* gemm_out_sqrsum, const float* hc_base, const float* hc_scale, bfloat16_t* layer_input, const bfloat16_t* norm_weight, float* post_mix, const bfloat16_t* residual, int num_tokens); +extern "C" __global__ void __launch_bounds__(96, 1) mhc_pre_big_fuse_with_norm_tilelang_kernel(float* comb_mix, const float* gemm_out_mul, const float* gemm_out_sqrsum, const float* hc_base, const float* hc_scale, bfloat16_t* layer_input, const bfloat16_t* norm_weight, float* post_mix, const bfloat16_t* residual, int num_tokens) { + extern __shared__ __align__(1024) uchar buf_dyn_shmem[]; + float mixes[1]; + float rms[1]; + float cm[1]; + float row_max[1]; + float row_sum[1]; + float col_sum[1]; + float sumsq_per_pos[16]; + float sumsq[1]; + float rsqrt_norm[1]; + float xl[64]; + float ol[16]; + bfloat16_t xs_local_cast[8]; + bfloat16_t xs_local_cast_1[8]; + bfloat16_t xs_local_cast_2[8]; + float w_local[16]; + float ol_1[16]; + bfloat16_t w_shared_local_cast_3[8]; + bfloat16_t output_shared_local_cast_4[8]; + bfloat16_t layer_input_local_cast_5[8]; + bfloat16_t w_shared_local_cast_6[8]; + bfloat16_t output_shared_local_cast_7[8]; + bfloat16_t layer_input_local_cast_8[8]; + bfloat16_t w_shared_local_cast_9[8]; + bfloat16_t output_shared_local_cast_10[8]; + bfloat16_t layer_input_local_cast_11[8]; + mixes[0] = 0x0p+0f/*0.000000e+00*/; + rms[0] = 0x0p+0f/*0.000000e+00*/; + cudaGridDependencySynchronize(); + for (int i_split = 0; i_split < 6; ++i_split) { + rms[0] = (rms[0] + gemm_out_sqrsum[((((int64_t)i_split) * ((int64_t)num_tokens)) + ((int64_t)((int)blockIdx.x)))]); + } + rms[0] = rsqrtf(((rms[0] / 0x1p+14f/*1.638400e+04*/) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + mixes[0] = 0x0p+0f/*0.000000e+00*/; + for (int i_split_1 = 0; i_split_1 < 6; ++i_split_1) { + mixes[0] = (mixes[0] + gemm_out_mul[(((((int64_t)((int)blockIdx.x)) * (int64_t)24) + ((((int64_t)i_split_1) * ((int64_t)num_tokens)) * (int64_t)24)) + (((int64_t)((int)threadIdx.x)) % (int64_t)24))]); + } + mixes[0] = (mixes[0] * rms[0]); + if ((((int)threadIdx.x) / 24) == 0) { + ((float*)buf_dyn_shmem)[(((int)threadIdx.x) % 24)] = mixes[0]; + } + __syncthreads(); + if (((int)threadIdx.x) < 32) { + if (((int)threadIdx.x) < 4) { + post_mix[((((int64_t)((int)blockIdx.x)) * (int64_t)4) + ((int64_t)((int)threadIdx.x)))] = ((0x1p+0f/*1.000000e+00*/ / (0x1p+0f/*1.000000e+00*/ + expf((0x0p+0f/*0.000000e+00*/ - ((((float*)buf_dyn_shmem)[(((int)threadIdx.x) + 4)] * hc_scale[1]) + hc_base[(((int)threadIdx.x) + 4)]))))) * 0x1p+1f/*2.000000e+00*/); + } + cm[0] = ((((float*)buf_dyn_shmem)[((((int)threadIdx.x) & 15) + 8)] * hc_scale[2]) + hc_base[((((int)threadIdx.x) & 15) + 8)]); + row_max[0] = -CUDART_INF_F; + row_max[0] = max(row_max[0], cm[0]); + row_max[0] = tl::AllReduce>::run(row_max[0]); + cm[0] = expf((cm[0] - row_max[0])); + row_sum[0] = 0x0p+0f/*0.000000e+00*/; + row_sum[0] = (row_sum[0] + cm[0]); + row_sum[0] = tl::AllReduce>::run(row_sum[0]); + cm[0] = ((cm[0] / row_sum[0]) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/); + col_sum[0] = 0x0p+0f/*0.000000e+00*/; + col_sum[0] = (col_sum[0] + cm[0]); + col_sum[0] = tl::AllReduce>::run(col_sum[0]); + cm[0] = (cm[0] / (col_sum[0] + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + for (int __1 = 0; __1 < 19; ++__1) { + row_sum[0] = 0x0p+0f/*0.000000e+00*/; + row_sum[0] = (row_sum[0] + cm[0]); + row_sum[0] = tl::AllReduce>::run(row_sum[0]); + cm[0] = (cm[0] / (row_sum[0] + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + col_sum[0] = 0x0p+0f/*0.000000e+00*/; + col_sum[0] = (col_sum[0] + cm[0]); + col_sum[0] = tl::AllReduce>::run(col_sum[0]); + cm[0] = (cm[0] / (col_sum[0] + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + } + if ((((int)threadIdx.x) >> 4) == 0) { + comb_mix[((((int64_t)((int)blockIdx.x)) * (int64_t)16) + (((int64_t)((int)threadIdx.x)) & (int64_t)15))] = cm[0]; + } + } else { + if (((int)threadIdx.x) < 36) { + ((float*)buf_dyn_shmem)[(((int)threadIdx.x) + 7224)] = ((0x1p+0f/*1.000000e+00*/ / (0x1p+0f/*1.000000e+00*/ + expf((0x0p+0f/*0.000000e+00*/ - ((((float*)buf_dyn_shmem)[(((int)threadIdx.x) - 32)] * hc_scale[0]) + hc_base[(((int)threadIdx.x) - 32)]))))) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/); + } + #pragma unroll + for (int i = 0; i < 4; ++i) { + float broadcast_var = 0x0p+0f/*0.000000e+00*/; + *(float4*)(sumsq_per_pos + (i * 4)) = make_float4(broadcast_var, broadcast_var, broadcast_var, broadcast_var); + } + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_1 = 0; i_1 < 8; ++i_1) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i_1 >> 1) * 1024) + (((((i_1 * 64) + ((int)threadIdx.x)) + 96) & 127) * 8)) + 48)])), (&(residual[(((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + ((((int64_t)i_1) >> (int64_t)1) * (int64_t)4096)) + (((((((int64_t)i_1) * (int64_t)64) + ((int64_t)((int)threadIdx.x))) + (int64_t)96) & (int64_t)127) * (int64_t)8))]))); + } + tl::cp_async_commit(); + #pragma unroll + for (int i_2 = 0; i_2 < 8; ++i_2) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i_2 >> 1) * 1024) + (((((i_2 * 64) + ((int)threadIdx.x)) + 96) & 127) * 8)) + 4144)])), (&(residual[((((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + ((((int64_t)i_2) >> (int64_t)1) * (int64_t)4096)) + (((((((int64_t)i_2) * (int64_t)64) + ((int64_t)((int)threadIdx.x))) + (int64_t)96) & (int64_t)127) * (int64_t)8)) + (int64_t)1024)]))); + } + tl::cp_async_commit(); + for (int i0_h = 0; i0_h < 2; ++i0_h) { + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_3 = 0; i_3 < 8; ++i_3) { + *(uint4*)(xs_local_cast + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + ((((i0_h * 4096) + (i_3 * 512)) + (((int)threadIdx.x) * 8)) - 208)); + for (int vec = 0; vec < 2; ++vec) { + float4 __2; + uint2 v_ = *(uint2*)(xs_local_cast + (vec * 4)); + ((float2*)(&__2))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v_))[0]); + ((float2*)(&__2))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v_))[1]); + *(float4*)(xl + ((i_3 * 8) + (vec * 4))) = __2; + } + } + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_4 = 0; i_4 < 8; ++i_4) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i0_h * 4096) + ((i_4 >> 1) * 1024)) + (((((i_4 * 64) + ((int)threadIdx.x)) + 96) & 127) * 8)) + 48)])), (&(residual[(((((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + ((((int64_t)i_4) >> (int64_t)1) * (int64_t)4096)) + (((int64_t)i0_h) * (int64_t)1024)) + (((((((int64_t)i_4) * (int64_t)64) + ((int64_t)((int)threadIdx.x))) + (int64_t)96) & (int64_t)127) * (int64_t)8)) + (int64_t)2048)]))); + } + tl::cp_async_commit(); + #pragma unroll + for (int i_5 = 0; i_5 < 4; ++i_5) { + float broadcast_var_1 = 0x0p+0f/*0.000000e+00*/; + *(float4*)(ol + (i_5 * 4)) = make_float4(broadcast_var_1, broadcast_var_1, broadcast_var_1, broadcast_var_1); + } + tl::__sync_thread_partial<3, 64>(); + for (int i_hc = 0; i_hc < 4; ++i_hc) { + float pre = ((float*)buf_dyn_shmem)[(i_hc + 7256)]; + #pragma unroll + for (int i_6 = 0; i_6 < 16; ++i_6) { + ol[i_6] = (ol[i_6] + (pre * xl[((i_hc * 16) + i_6)])); + } + } + #pragma unroll + for (int i_7 = 0; i_7 < 4; ++i_7) { + float4 __3; + float4 v__1 = *(float4*)(sumsq_per_pos + (i_7 * 4)); + float4 __4; + float4 v__2 = *(float4*)(ol + (i_7 * 4)); + __4.x = (v__2.x*v__2.x); + __4.y = (v__2.y*v__2.y); + __4.z = (v__2.z*v__2.z); + __4.w = (v__2.w*v__2.w); + __3.x = (v__1.x+__4.x); + __3.y = (v__1.y+__4.y); + __3.z = (v__1.z+__4.z); + __3.w = (v__1.w+__4.w); + *(float4*)(sumsq_per_pos + (i_7 * 4)) = __3; + uint2 __5; + float4 v__3 = *(float4*)(ol + (i_7 * 4)); + (reinterpret_cast<__nv_bfloat162*>(&__5))[0] = __float22bfloat162_rn(((float2*)(&v__3))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__5))[1] = __float22bfloat162_rn(((float2*)(&v__3))[1]); + *(uint2*)(((bfloat16_t*)buf_dyn_shmem) + (((((i0_h * 1024) + ((i_7 >> 1) * 512)) + (((int)threadIdx.x) * 8)) + ((i_7 & 1) * 4)) + 7984)) = __5; + } + } + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_8 = 0; i_8 < 8; ++i_8) { + *(uint4*)(xs_local_cast_1 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_8 * 512) + (((int)threadIdx.x) * 8)) - 208)); + for (int vec_1 = 0; vec_1 < 2; ++vec_1) { + float4 __6; + uint2 v__4 = *(uint2*)(xs_local_cast_1 + (vec_1 * 4)); + ((float2*)(&__6))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__4))[0]); + ((float2*)(&__6))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__4))[1]); + *(float4*)(xl + ((i_8 * 8) + (vec_1 * 4))) = __6; + } + } + #pragma unroll + for (int i_9 = 0; i_9 < 4; ++i_9) { + float broadcast_var_2 = 0x0p+0f/*0.000000e+00*/; + *(float4*)(ol + (i_9 * 4)) = make_float4(broadcast_var_2, broadcast_var_2, broadcast_var_2, broadcast_var_2); + } + for (int i_hc_1 = 0; i_hc_1 < 4; ++i_hc_1) { + float pre_1 = ((float*)buf_dyn_shmem)[(i_hc_1 + 7256)]; + #pragma unroll + for (int i_10 = 0; i_10 < 16; ++i_10) { + ol[i_10] = (ol[i_10] + (pre_1 * xl[((i_hc_1 * 16) + i_10)])); + } + } + #pragma unroll + for (int i_11 = 0; i_11 < 4; ++i_11) { + float4 __7; + float4 v__5 = *(float4*)(sumsq_per_pos + (i_11 * 4)); + float4 __8; + float4 v__6 = *(float4*)(ol + (i_11 * 4)); + __8.x = (v__6.x*v__6.x); + __8.y = (v__6.y*v__6.y); + __8.z = (v__6.z*v__6.z); + __8.w = (v__6.w*v__6.w); + __7.x = (v__5.x+__8.x); + __7.y = (v__5.y+__8.y); + __7.z = (v__5.z+__8.z); + __7.w = (v__5.w+__8.w); + *(float4*)(sumsq_per_pos + (i_11 * 4)) = __7; + uint2 __9; + float4 v__7 = *(float4*)(ol + (i_11 * 4)); + (reinterpret_cast<__nv_bfloat162*>(&__9))[0] = __float22bfloat162_rn(((float2*)(&v__7))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__9))[1] = __float22bfloat162_rn(((float2*)(&v__7))[1]); + *(uint2*)(((bfloat16_t*)buf_dyn_shmem) + (((((i_11 >> 1) * 512) + (((int)threadIdx.x) * 8)) + ((i_11 & 1) * 4)) + 10032)) = __9; + } + tl::cp_async_wait<0>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_12 = 0; i_12 < 8; ++i_12) { + *(uint4*)(xs_local_cast_2 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_12 * 512) + (((int)threadIdx.x) * 8)) + 3888)); + for (int vec_2 = 0; vec_2 < 2; ++vec_2) { + float4 __10; + uint2 v__8 = *(uint2*)(xs_local_cast_2 + (vec_2 * 4)); + ((float2*)(&__10))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__8))[0]); + ((float2*)(&__10))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__8))[1]); + *(float4*)(xl + ((i_12 * 8) + (vec_2 * 4))) = __10; + } + } + #pragma unroll + for (int i_13 = 0; i_13 < 4; ++i_13) { + float broadcast_var_3 = 0x0p+0f/*0.000000e+00*/; + *(float4*)(ol + (i_13 * 4)) = make_float4(broadcast_var_3, broadcast_var_3, broadcast_var_3, broadcast_var_3); + } + for (int i_hc_2 = 0; i_hc_2 < 4; ++i_hc_2) { + float pre_2 = ((float*)buf_dyn_shmem)[(i_hc_2 + 7256)]; + #pragma unroll + for (int i_14 = 0; i_14 < 16; ++i_14) { + ol[i_14] = (ol[i_14] + (pre_2 * xl[((i_hc_2 * 16) + i_14)])); + } + } + #pragma unroll + for (int i_15 = 0; i_15 < 4; ++i_15) { + float4 __11; + float4 v__9 = *(float4*)(sumsq_per_pos + (i_15 * 4)); + float4 __12; + float4 v__10 = *(float4*)(ol + (i_15 * 4)); + __12.x = (v__10.x*v__10.x); + __12.y = (v__10.y*v__10.y); + __12.z = (v__10.z*v__10.z); + __12.w = (v__10.w*v__10.w); + __11.x = (v__9.x+__12.x); + __11.y = (v__9.y+__12.y); + __11.z = (v__9.z+__12.z); + __11.w = (v__9.w+__12.w); + *(float4*)(sumsq_per_pos + (i_15 * 4)) = __11; + uint2 __13; + float4 v__11 = *(float4*)(ol + (i_15 * 4)); + (reinterpret_cast<__nv_bfloat162*>(&__13))[0] = __float22bfloat162_rn(((float2*)(&v__11))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__13))[1] = __float22bfloat162_rn(((float2*)(&v__11))[1]); + *(uint2*)(((bfloat16_t*)buf_dyn_shmem) + (((((i_15 >> 1) * 512) + (((int)threadIdx.x) * 8)) + ((i_15 & 1) * 4)) + 11056)) = __13; + } + sumsq[0] = 0x0p+0f/*0.000000e+00*/; + #pragma unroll + for (int rv = 0; rv < 16; ++rv) { + sumsq[0] = (sumsq[0] + sumsq_per_pos[(((rv & 1) * 8) + (rv >> 1))]); + } + tl::__sync_thread_partial<3, 64>(); + sumsq[0] = tl::AllReduce>::run(sumsq[0], (&(((float*)buf_dyn_shmem)[7192]))); + rsqrt_norm[0] = rsqrtf(((sumsq[0] / 0x1p+12f/*4.096000e+03*/) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + #pragma unroll + for (int i_16 = 0; i_16 < 2; ++i_16) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[(((i_16 * 512) + (((int)threadIdx.x) * 8)) + 12080)])), (&(norm_weight[(((i_16 * 512) + (((int)threadIdx.x) * 8)) - 256)]))); + } + tl::cp_async_commit(); + #pragma unroll + for (int i_17 = 0; i_17 < 2; ++i_17) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[(((i_17 * 512) + (((int)threadIdx.x) * 8)) + 13104)])), (&(norm_weight[(((i_17 * 512) + (((int)threadIdx.x) * 8)) + 768)]))); + } + tl::cp_async_commit(); + for (int i0_h_1 = 0; i0_h_1 < 2; ++i0_h_1) { + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_18 = 0; i_18 < 2; ++i_18) { + *(uint4*)(w_shared_local_cast_3 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + ((((i0_h_1 * 1024) + (i_18 * 512)) + (((int)threadIdx.x) * 8)) + 12080)); + for (int vec_3 = 0; vec_3 < 2; ++vec_3) { + float4 __14; + uint2 v__12 = *(uint2*)(w_shared_local_cast_3 + (vec_3 * 4)); + ((float2*)(&__14))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__12))[0]); + ((float2*)(&__14))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__12))[1]); + *(float4*)(w_local + ((i_18 * 8) + (vec_3 * 4))) = __14; + } + } + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_19 = 0; i_19 < 2; ++i_19) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i0_h_1 * 1024) + (i_19 * 512)) + (((int)threadIdx.x) * 8)) + 12080)])), (&(norm_weight[((((i0_h_1 * 1024) + (i_19 * 512)) + (((int)threadIdx.x) * 8)) + 1792)]))); + } + tl::cp_async_commit(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_20 = 0; i_20 < 2; ++i_20) { + *(uint4*)(output_shared_local_cast_4 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + ((((i0_h_1 * 1024) + (i_20 * 512)) + (((int)threadIdx.x) * 8)) + 7984)); + for (int vec_4 = 0; vec_4 < 2; ++vec_4) { + float4 __15; + float4 __16; + float4 __17; + uint2 v__13 = *(uint2*)(output_shared_local_cast_4 + (vec_4 * 4)); + ((float2*)(&__17))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__13))[0]); + ((float2*)(&__17))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__13))[1]); + float4 v__14 = make_float4(rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0]); + __16.x = (__17.x*v__14.x); + __16.y = (__17.y*v__14.y); + __16.z = (__17.z*v__14.z); + __16.w = (__17.w*v__14.w); + float4 v__15 = *(float4*)(w_local + ((i_20 * 8) + (vec_4 * 4))); + __15.x = (__16.x*v__15.x); + __15.y = (__16.y*v__15.y); + __15.z = (__16.z*v__15.z); + __15.w = (__16.w*v__15.w); + *(float4*)(ol_1 + ((i_20 * 8) + (vec_4 * 4))) = __15; + } + } + #pragma unroll + for (int i_21 = 0; i_21 < 2; ++i_21) { + for (int vec_5 = 0; vec_5 < 2; ++vec_5) { + uint2 __18; + float4 v__16 = *(float4*)(ol_1 + ((i_21 * 8) + (vec_5 * 4))); + (reinterpret_cast<__nv_bfloat162*>(&__18))[0] = __float22bfloat162_rn(((float2*)(&v__16))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__18))[1] = __float22bfloat162_rn(((float2*)(&v__16))[1]); + *(uint2*)(layer_input_local_cast_5 + (vec_5 * 4)) = __18; + } + *(uint4*)(layer_input + (((((((int64_t)((int)blockIdx.x)) * (int64_t)4096) + (((int64_t)i0_h_1) * (int64_t)1024)) + (((int64_t)i_21) * (int64_t)512)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8)) - (int64_t)256)) = *(uint4*)(layer_input_local_cast_5 + 0); + } + } + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_22 = 0; i_22 < 2; ++i_22) { + *(uint4*)(w_shared_local_cast_6 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_22 * 512) + (((int)threadIdx.x) * 8)) + 12080)); + for (int vec_6 = 0; vec_6 < 2; ++vec_6) { + float4 __19; + uint2 v__17 = *(uint2*)(w_shared_local_cast_6 + (vec_6 * 4)); + ((float2*)(&__19))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__17))[0]); + ((float2*)(&__19))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__17))[1]); + *(float4*)(w_local + ((i_22 * 8) + (vec_6 * 4))) = __19; + } + } + #pragma unroll + for (int i_23 = 0; i_23 < 2; ++i_23) { + *(uint4*)(output_shared_local_cast_7 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_23 * 512) + (((int)threadIdx.x) * 8)) + 10032)); + for (int vec_7 = 0; vec_7 < 2; ++vec_7) { + float4 __20; + float4 __21; + float4 __22; + uint2 v__18 = *(uint2*)(output_shared_local_cast_7 + (vec_7 * 4)); + ((float2*)(&__22))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__18))[0]); + ((float2*)(&__22))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__18))[1]); + float4 v__19 = make_float4(rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0]); + __21.x = (__22.x*v__19.x); + __21.y = (__22.y*v__19.y); + __21.z = (__22.z*v__19.z); + __21.w = (__22.w*v__19.w); + float4 v__20 = *(float4*)(w_local + ((i_23 * 8) + (vec_7 * 4))); + __20.x = (__21.x*v__20.x); + __20.y = (__21.y*v__20.y); + __20.z = (__21.z*v__20.z); + __20.w = (__21.w*v__20.w); + *(float4*)(ol_1 + ((i_23 * 8) + (vec_7 * 4))) = __20; + } + } + #pragma unroll + for (int i_24 = 0; i_24 < 2; ++i_24) { + for (int vec_8 = 0; vec_8 < 2; ++vec_8) { + uint2 __23; + float4 v__21 = *(float4*)(ol_1 + ((i_24 * 8) + (vec_8 * 4))); + (reinterpret_cast<__nv_bfloat162*>(&__23))[0] = __float22bfloat162_rn(((float2*)(&v__21))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__23))[1] = __float22bfloat162_rn(((float2*)(&v__21))[1]); + *(uint2*)(layer_input_local_cast_8 + (vec_8 * 4)) = __23; + } + *(uint4*)(layer_input + ((((((int64_t)((int)blockIdx.x)) * (int64_t)4096) + (((int64_t)i_24) * (int64_t)512)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8)) + (int64_t)1792)) = *(uint4*)(layer_input_local_cast_8 + 0); + } + tl::cp_async_wait<0>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_25 = 0; i_25 < 2; ++i_25) { + *(uint4*)(w_shared_local_cast_9 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_25 * 512) + (((int)threadIdx.x) * 8)) + 13104)); + for (int vec_9 = 0; vec_9 < 2; ++vec_9) { + float4 __24; + uint2 v__22 = *(uint2*)(w_shared_local_cast_9 + (vec_9 * 4)); + ((float2*)(&__24))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__22))[0]); + ((float2*)(&__24))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__22))[1]); + *(float4*)(w_local + ((i_25 * 8) + (vec_9 * 4))) = __24; + } + } + #pragma unroll + for (int i_26 = 0; i_26 < 2; ++i_26) { + *(uint4*)(output_shared_local_cast_10 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_26 * 512) + (((int)threadIdx.x) * 8)) + 11056)); + for (int vec_10 = 0; vec_10 < 2; ++vec_10) { + float4 __25; + float4 __26; + float4 __27; + uint2 v__23 = *(uint2*)(output_shared_local_cast_10 + (vec_10 * 4)); + ((float2*)(&__27))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__23))[0]); + ((float2*)(&__27))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__23))[1]); + float4 v__24 = make_float4(rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0]); + __26.x = (__27.x*v__24.x); + __26.y = (__27.y*v__24.y); + __26.z = (__27.z*v__24.z); + __26.w = (__27.w*v__24.w); + float4 v__25 = *(float4*)(w_local + ((i_26 * 8) + (vec_10 * 4))); + __25.x = (__26.x*v__25.x); + __25.y = (__26.y*v__25.y); + __25.z = (__26.z*v__25.z); + __25.w = (__26.w*v__25.w); + *(float4*)(ol_1 + ((i_26 * 8) + (vec_10 * 4))) = __25; + } + } + #pragma unroll + for (int i_27 = 0; i_27 < 2; ++i_27) { + for (int vec_11 = 0; vec_11 < 2; ++vec_11) { + uint2 __28; + float4 v__26 = *(float4*)(ol_1 + ((i_27 * 8) + (vec_11 * 4))); + (reinterpret_cast<__nv_bfloat162*>(&__28))[0] = __float22bfloat162_rn(((float2*)(&v__26))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__28))[1] = __float22bfloat162_rn(((float2*)(&v__26))[1]); + *(uint2*)(layer_input_local_cast_11 + (vec_11 * 4)) = __28; + } + *(uint4*)(layer_input + ((((((int64_t)((int)blockIdx.x)) * (int64_t)4096) + (((int64_t)i_27) * (int64_t)512)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8)) + (int64_t)2816)) = *(uint4*)(layer_input_local_cast_11 + 0); + } + } + cudaTriggerProgrammaticLaunchCompletion(); +} + diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/1f417b351704372ae9697b314cec4913d9e69469d246e2c9d2c8400a16396625/host_kernel.cu b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/1f417b351704372ae9697b314cec4913d9e69469d246e2c9d2c8400a16396625/host_kernel.cu new file mode 100644 index 0000000..13dbe06 --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/1f417b351704372ae9697b314cec4913d9e69469d246e2c9d2c8400a16396625/host_kernel.cu @@ -0,0 +1,3359 @@ +// tilelang target: c -keys=cpu +#define TVM_EXPORTS +#include "tvm/runtime/base.h" +#include "tvm/runtime/c_backend_api.h" +#include "tvm/ffi/c_api.h" +#include +#include +#include +#ifdef __OBJC__ +#include "tvm/runtime/device_api.h" +#include "tvm/ffi/function.h" +#include +#include +#include +#endif +void* __tvm_ffi__library_ctx = NULL; +static void* __tvm_error_ndim_mismatch_packed = NULL; +static void* __tvm_error_dtype_mismatch_packed = NULL; +static void* __tvm_error_expect_eq_packed = NULL; +static void* __tvm_error_constraint_violation_packed = NULL; +static void* __tvm_error_byte_offset_mismatch_packed = NULL; +static void* __tvm_error_device_type_mismatch_packed = NULL; +static void* __tvm_error_null_ptr_packed = NULL; +static void* __tvm_set_device_packed = NULL; +static void* mhc_pre_big_fuse_with_norm_tilelang_kernel_packed = NULL; +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_mhc_pre_big_fuse_with_norm_tilelang(void* self_handle, void* args, int32_t num_args, void* result); +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_mhc_pre_big_fuse_with_norm_tilelang(void* self_handle, void* args, int32_t num_args, void* result) { + __attribute__((aligned(64))) TVMFFIAny stack[16]; + void* stack_ffi_any = stack; + if (!((num_args == 9))) { + char __tvm_assert_msg_buf[512]; + snprintf(__tvm_assert_msg_buf, 512, "%s; expected: %lld, got: %lld", "mhc_pre_big_fuse_with_norm_tilelang: num_args should be 9", (long long)(num_args), (long long)(9)); + TVMFFIErrorSetRaisedFromCStr("RuntimeError", __tvm_assert_msg_buf); + return -1; + } + if (!(!(args == NULL))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang: args pointer is NULL"); + return -1; + } + int32_t gemm_out_mul_type_index = (((TVMFFIAny*)args)[0].type_index); + if (!(((((gemm_out_mul_type_index == 0) || (gemm_out_mul_type_index == 4)) || (gemm_out_mul_type_index == 7)) || (64 <= gemm_out_mul_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input gemm_out_mul expected pointer or tensor handle"); + return -1; + } + int32_t gemm_out_sqrsum_type_index = (((TVMFFIAny*)args)[1].type_index); + if (!(((((gemm_out_sqrsum_type_index == 0) || (gemm_out_sqrsum_type_index == 4)) || (gemm_out_sqrsum_type_index == 7)) || (64 <= gemm_out_sqrsum_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input gemm_out_sqrsum expected pointer or tensor handle"); + return -1; + } + int32_t hc_scale_type_index = (((TVMFFIAny*)args)[2].type_index); + if (!(((((hc_scale_type_index == 0) || (hc_scale_type_index == 4)) || (hc_scale_type_index == 7)) || (64 <= hc_scale_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input hc_scale expected pointer or tensor handle"); + return -1; + } + int32_t hc_base_type_index = (((TVMFFIAny*)args)[3].type_index); + if (!(((((hc_base_type_index == 0) || (hc_base_type_index == 4)) || (hc_base_type_index == 7)) || (64 <= hc_base_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input hc_base expected pointer or tensor handle"); + return -1; + } + int32_t residual_type_index = (((TVMFFIAny*)args)[4].type_index); + if (!(((((residual_type_index == 0) || (residual_type_index == 4)) || (residual_type_index == 7)) || (64 <= residual_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input residual expected pointer or tensor handle"); + return -1; + } + int32_t post_mix_type_index = (((TVMFFIAny*)args)[5].type_index); + if (!(((((post_mix_type_index == 0) || (post_mix_type_index == 4)) || (post_mix_type_index == 7)) || (64 <= post_mix_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input post_mix expected pointer or tensor handle"); + return -1; + } + int32_t comb_mix_type_index = (((TVMFFIAny*)args)[6].type_index); + if (!(((((comb_mix_type_index == 0) || (comb_mix_type_index == 4)) || (comb_mix_type_index == 7)) || (64 <= comb_mix_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input comb_mix expected pointer or tensor handle"); + return -1; + } + int32_t layer_input_type_index = (((TVMFFIAny*)args)[7].type_index); + if (!(((((layer_input_type_index == 0) || (layer_input_type_index == 4)) || (layer_input_type_index == 7)) || (64 <= layer_input_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input layer_input expected pointer or tensor handle"); + return -1; + } + int32_t norm_weight_type_index = (((TVMFFIAny*)args)[8].type_index); + if (!(((((norm_weight_type_index == 0) || (norm_weight_type_index == 4)) || (norm_weight_type_index == 7)) || (64 <= norm_weight_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input norm_weight expected pointer or tensor handle"); + return -1; + } + void* gemm_out_mul = ((gemm_out_mul_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[0].v_ptr) + 24)) : (((TVMFFIAny*)args)[0].v_ptr)); + void* gemm_out_sqrsum = ((gemm_out_sqrsum_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[1].v_ptr) + 24)) : (((TVMFFIAny*)args)[1].v_ptr)); + void* hc_scale = ((hc_scale_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[2].v_ptr) + 24)) : (((TVMFFIAny*)args)[2].v_ptr)); + void* hc_base = ((hc_base_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[3].v_ptr) + 24)) : (((TVMFFIAny*)args)[3].v_ptr)); + void* residual = ((residual_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[4].v_ptr) + 24)) : (((TVMFFIAny*)args)[4].v_ptr)); + void* post_mix = ((post_mix_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[5].v_ptr) + 24)) : (((TVMFFIAny*)args)[5].v_ptr)); + void* comb_mix = ((comb_mix_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[6].v_ptr) + 24)) : (((TVMFFIAny*)args)[6].v_ptr)); + void* layer_input = ((layer_input_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[7].v_ptr) + 24)) : (((TVMFFIAny*)args)[7].v_ptr)); + void* norm_weight = ((norm_weight_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[8].v_ptr) + 24)) : (((TVMFFIAny*)args)[8].v_ptr)); + bool mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_is_null = (gemm_out_mul == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.gemm_out_mul is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_is_null = (gemm_out_sqrsum == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.gemm_out_sqrsum is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_hc_scale_is_null = (hc_scale == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_hc_scale_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.hc_scale is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_hc_base_is_null = (hc_base == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_hc_base_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.hc_base is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_residual_is_null = (residual == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_residual_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.residual is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_post_mix_is_null = (post_mix == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_post_mix_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.post_mix is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_comb_mix_is_null = (comb_mix == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_comb_mix_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.comb_mix is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_layer_input_is_null = (layer_input == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_layer_input_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.layer_input is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_norm_weight_is_null = (norm_weight == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_norm_weight_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.norm_weight is expected to have non-NULL pointer"); + return -1; + } + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape = (((DLTensor*)gemm_out_mul)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape = (((DLTensor*)gemm_out_sqrsum)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_hc_scale_shape = (((DLTensor*)hc_scale)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_hc_base_shape = (((DLTensor*)hc_base)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_residual_shape = (((DLTensor*)residual)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape = (((DLTensor*)post_mix)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape = (((DLTensor*)comb_mix)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape = (((DLTensor*)layer_input)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_norm_weight_shape = (((DLTensor*)norm_weight)[0].shape); + if ((((DLTensor*)gemm_out_mul)[0].ndim) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_1; + result_1.type_index = kTVMFFINone; + result_1.zero_padding = 0; + result_1.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_1) != 0) { + return -1; + } + } + if (!((bool)1)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "Symbolic shape variable num_tokens requires at least one non-null buffer among: mhc_pre_big_fuse_with_norm_tilelang.gemm_out_mul, mhc_pre_big_fuse_with_norm_tilelang.gemm_out_sqrsum, mhc_pre_big_fuse_with_norm_tilelang.residual, mhc_pre_big_fuse_with_norm_tilelang.post_mix, mhc_pre_big_fuse_with_norm_tilelang.comb_mix, mhc_pre_big_fuse_with_norm_tilelang.layer_input"); + return -1; + } + int32_t num_tokens = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]); + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides = (((DLTensor*)gemm_out_mul)[0].strides); + int32_t dev_id = (((DLTensor*)gemm_out_mul)[0].device.device_id); + void* gemm_out_mul_1 = (((DLTensor*)gemm_out_mul)[0].data); + if ((((DLTensor*)gemm_out_sqrsum)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_2; + result_2.type_index = kTVMFFINone; + result_2.zero_padding = 0; + result_2.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_2) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides = (((DLTensor*)gemm_out_sqrsum)[0].strides); + void* gemm_out_sqrsum_1 = (((DLTensor*)gemm_out_sqrsum)[0].data); + if ((((DLTensor*)hc_scale)[0].ndim) != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_3; + result_3.type_index = kTVMFFINone; + result_3.zero_padding = 0; + result_3.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_3) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides = (((DLTensor*)hc_scale)[0].strides); + void* hc_scale_1 = (((DLTensor*)hc_scale)[0].data); + if ((((DLTensor*)hc_base)[0].ndim) != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_4; + result_4.type_index = kTVMFFINone; + result_4.zero_padding = 0; + result_4.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_4) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides = (((DLTensor*)hc_base)[0].strides); + void* hc_base_1 = (((DLTensor*)hc_base)[0].data); + if ((((DLTensor*)residual)[0].ndim) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_5; + result_5.type_index = kTVMFFINone; + result_5.zero_padding = 0; + result_5.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_5) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_residual_strides = (((DLTensor*)residual)[0].strides); + void* residual_1 = (((DLTensor*)residual)[0].data); + if ((((DLTensor*)post_mix)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_6; + result_6.type_index = kTVMFFINone; + result_6.zero_padding = 0; + result_6.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_6) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides = (((DLTensor*)post_mix)[0].strides); + void* post_mix_1 = (((DLTensor*)post_mix)[0].data); + if ((((DLTensor*)comb_mix)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_7; + result_7.type_index = kTVMFFINone; + result_7.zero_padding = 0; + result_7.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_7) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides = (((DLTensor*)comb_mix)[0].strides); + void* comb_mix_1 = (((DLTensor*)comb_mix)[0].data); + if ((((DLTensor*)layer_input)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_8; + result_8.type_index = kTVMFFINone; + result_8.zero_padding = 0; + result_8.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_8) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides = (((DLTensor*)layer_input)[0].strides); + void* layer_input_1 = (((DLTensor*)layer_input)[0].data); + if ((((DLTensor*)norm_weight)[0].ndim) != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_9; + result_9.type_index = kTVMFFINone; + result_9.zero_padding = 0; + result_9.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_9) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides = (((DLTensor*)norm_weight)[0].strides); + void* norm_weight_1 = (((DLTensor*)norm_weight)[0].data); + if ((((((DLTensor*)gemm_out_mul)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)gemm_out_mul)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)gemm_out_mul)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_10; + result_10.type_index = kTVMFFINone; + result_10.zero_padding = 0; + result_10.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_10) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[0]) != 6) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)6; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_11; + result_11.type_index = kTVMFFINone; + result_11.zero_padding = 0; + result_11.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_11) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[2]) != 24) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)24; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[2])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_12; + result_12.type_index = kTVMFFINone; + result_12.zero_padding = 0; + result_12.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_12) != 0) { + return -1; + } + } + int32_t condval; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval = 1; + } else { + condval = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[2]); + } + if (condval != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_1; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval_1 = 1; + } else { + condval_1 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[2]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_1); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_13; + result_13.type_index = kTVMFFINone; + result_13.zero_padding = 0; + result_13.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_13) != 0) { + return -1; + } + } + int32_t condval_2; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval_2 = 1; + } else { + condval_2 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[1]); + } + if ((condval_2 != 24) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_14; + result_14.type_index = kTVMFFINone; + result_14.zero_padding = 0; + result_14.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_14) != 0) { + return -1; + } + } + int32_t condval_3; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval_3 = 1; + } else { + condval_3 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[0]); + } + if (((num_tokens * 24) != condval_3) && (num_tokens != 0)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_15; + result_15.type_index = kTVMFFINone; + result_15.zero_padding = 0; + result_15.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_15) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)gemm_out_mul)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_16; + result_16.type_index = kTVMFFINone; + result_16.zero_padding = 0; + result_16.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_16) != 0) { + return -1; + } + } + if ((((DLTensor*)gemm_out_mul)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_17; + result_17.type_index = kTVMFFINone; + result_17.zero_padding = 0; + result_17.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_17) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (gemm_out_mul_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_18; + result_18.type_index = kTVMFFINone; + result_18.zero_padding = 0; + result_18.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_18) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)gemm_out_sqrsum)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)gemm_out_sqrsum)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)gemm_out_sqrsum)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_19; + result_19.type_index = kTVMFFINone; + result_19.zero_padding = 0; + result_19.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_19) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[0]) != 6) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)6; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_20; + result_20.type_index = kTVMFFINone; + result_20.zero_padding = 0; + result_20.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_20) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[1])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_21; + result_21.type_index = kTVMFFINone; + result_21.zero_padding = 0; + result_21.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_21) != 0) { + return -1; + } + } + int32_t condval_4; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides == NULL)) { + condval_4 = 1; + } else { + condval_4 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides)[1]); + } + if ((condval_4 != 1) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_22; + result_22.type_index = kTVMFFINone; + result_22.zero_padding = 0; + result_22.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_22) != 0) { + return -1; + } + } + int32_t condval_5; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides == NULL)) { + condval_5 = 1; + } else { + condval_5 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides)[0]); + } + if ((((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != condval_5) && (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != 0)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_23; + result_23.type_index = kTVMFFINone; + result_23.zero_padding = 0; + result_23.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_23) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)gemm_out_sqrsum)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_24; + result_24.type_index = kTVMFFINone; + result_24.zero_padding = 0; + result_24.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_24) != 0) { + return -1; + } + } + if ((((DLTensor*)gemm_out_sqrsum)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_25; + result_25.type_index = kTVMFFINone; + result_25.zero_padding = 0; + result_25.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_25) != 0) { + return -1; + } + } + if ((((DLTensor*)gemm_out_sqrsum)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_26; + result_26.type_index = kTVMFFINone; + result_26.zero_padding = 0; + result_26.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_26) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (gemm_out_sqrsum_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_27; + result_27.type_index = kTVMFFINone; + result_27.zero_padding = 0; + result_27.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_27) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)hc_scale)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)hc_scale)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)hc_scale)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_28; + result_28.type_index = kTVMFFINone; + result_28.zero_padding = 0; + result_28.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_28) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_shape)[0]) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_29; + result_29.type_index = kTVMFFINone; + result_29.zero_padding = 0; + result_29.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_29) != 0) { + return -1; + } + } + int32_t condval_6; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides == NULL)) { + condval_6 = 1; + } else { + condval_6 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides)[0]); + } + if (condval_6 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_7; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides == NULL)) { + condval_7 = 1; + } else { + condval_7 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides)[0]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_7); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_30; + result_30.type_index = kTVMFFINone; + result_30.zero_padding = 0; + result_30.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_30) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)hc_scale)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_31; + result_31.type_index = kTVMFFINone; + result_31.zero_padding = 0; + result_31.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_31) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_scale)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_32; + result_32.type_index = kTVMFFINone; + result_32.zero_padding = 0; + result_32.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_32) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_scale)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_33; + result_33.type_index = kTVMFFINone; + result_33.zero_padding = 0; + result_33.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_33) != 0) { + return -1; + } + } + if (hc_scale_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_34; + result_34.type_index = kTVMFFINone; + result_34.zero_padding = 0; + result_34.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_34) != 0) { + return -1; + } + } + if ((((((DLTensor*)hc_base)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)hc_base)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)hc_base)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_35; + result_35.type_index = kTVMFFINone; + result_35.zero_padding = 0; + result_35.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_35) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_shape)[0]) != 24) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)24; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_36; + result_36.type_index = kTVMFFINone; + result_36.zero_padding = 0; + result_36.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_36) != 0) { + return -1; + } + } + int32_t condval_8; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides == NULL)) { + condval_8 = 1; + } else { + condval_8 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides)[0]); + } + if (condval_8 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_9; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides == NULL)) { + condval_9 = 1; + } else { + condval_9 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides)[0]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_9); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_37; + result_37.type_index = kTVMFFINone; + result_37.zero_padding = 0; + result_37.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_37) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)hc_base)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_38; + result_38.type_index = kTVMFFINone; + result_38.zero_padding = 0; + result_38.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_38) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_base)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_39; + result_39.type_index = kTVMFFINone; + result_39.zero_padding = 0; + result_39.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_39) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_base)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_40; + result_40.type_index = kTVMFFINone; + result_40.zero_padding = 0; + result_40.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_40) != 0) { + return -1; + } + } + if (hc_base_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_41; + result_41.type_index = kTVMFFINone; + result_41.zero_padding = 0; + result_41.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_41) != 0) { + return -1; + } + } + if ((((((DLTensor*)residual)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)residual)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)residual)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)residual)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)residual)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_42; + result_42.type_index = kTVMFFINone; + result_42.zero_padding = 0; + result_42.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_42) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_43; + result_43.type_index = kTVMFFINone; + result_43.zero_padding = 0; + result_43.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_43) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[1]) != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_44; + result_44.type_index = kTVMFFINone; + result_44.zero_padding = 0; + result_44.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_44) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[2]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[2])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_45; + result_45.type_index = kTVMFFINone; + result_45.zero_padding = 0; + result_45.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_45) != 0) { + return -1; + } + } + int32_t condval_10; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_10 = 1; + } else { + condval_10 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[2]); + } + if (condval_10 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_11; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_11 = 1; + } else { + condval_11 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[2]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_11); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_46; + result_46.type_index = kTVMFFINone; + result_46.zero_padding = 0; + result_46.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_46) != 0) { + return -1; + } + } + int32_t condval_12; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_12 = 1; + } else { + condval_12 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[1]); + } + if (condval_12 != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_13; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_13 = 1; + } else { + condval_13 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_13); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_47; + result_47.type_index = kTVMFFINone; + result_47.zero_padding = 0; + result_47.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_47) != 0) { + return -1; + } + } + int32_t condval_14; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_14 = 1; + } else { + condval_14 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[0]); + } + if ((condval_14 != 16384) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_48; + result_48.type_index = kTVMFFINone; + result_48.zero_padding = 0; + result_48.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_48) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)residual)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_49; + result_49.type_index = kTVMFFINone; + result_49.zero_padding = 0; + result_49.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_49) != 0) { + return -1; + } + } + if ((((DLTensor*)residual)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)residual)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_50; + result_50.type_index = kTVMFFINone; + result_50.zero_padding = 0; + result_50.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_50) != 0) { + return -1; + } + } + if ((((DLTensor*)residual)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_51; + result_51.type_index = kTVMFFINone; + result_51.zero_padding = 0; + result_51.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_51) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (residual_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_52; + result_52.type_index = kTVMFFINone; + result_52.zero_padding = 0; + result_52.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_52) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)post_mix)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)post_mix)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)post_mix)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_53; + result_53.type_index = kTVMFFINone; + result_53.zero_padding = 0; + result_53.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_53) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_54; + result_54.type_index = kTVMFFINone; + result_54.zero_padding = 0; + result_54.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_54) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[1]) != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_55; + result_55.type_index = kTVMFFINone; + result_55.zero_padding = 0; + result_55.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_55) != 0) { + return -1; + } + } + int32_t condval_15; + if ((mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides == NULL)) { + condval_15 = 1; + } else { + condval_15 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides)[1]); + } + if (condval_15 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_16; + if ((mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides == NULL)) { + condval_16 = 1; + } else { + condval_16 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_16); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_56; + result_56.type_index = kTVMFFINone; + result_56.zero_padding = 0; + result_56.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_56) != 0) { + return -1; + } + } + int32_t condval_17; + if ((mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides == NULL)) { + condval_17 = 1; + } else { + condval_17 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides)[0]); + } + if ((condval_17 != 4) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_57; + result_57.type_index = kTVMFFINone; + result_57.zero_padding = 0; + result_57.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_57) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)post_mix)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_58; + result_58.type_index = kTVMFFINone; + result_58.zero_padding = 0; + result_58.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_58) != 0) { + return -1; + } + } + if ((((DLTensor*)post_mix)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_59; + result_59.type_index = kTVMFFINone; + result_59.zero_padding = 0; + result_59.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_59) != 0) { + return -1; + } + } + if ((((DLTensor*)post_mix)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_60; + result_60.type_index = kTVMFFINone; + result_60.zero_padding = 0; + result_60.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_60) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (post_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_61; + result_61.type_index = kTVMFFINone; + result_61.zero_padding = 0; + result_61.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_61) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)comb_mix)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)comb_mix)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)comb_mix)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_62; + result_62.type_index = kTVMFFINone; + result_62.zero_padding = 0; + result_62.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_62) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_63; + result_63.type_index = kTVMFFINone; + result_63.zero_padding = 0; + result_63.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_63) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[1]) != 16) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_64; + result_64.type_index = kTVMFFINone; + result_64.zero_padding = 0; + result_64.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_64) != 0) { + return -1; + } + } + int32_t condval_18; + if ((mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides == NULL)) { + condval_18 = 1; + } else { + condval_18 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides)[1]); + } + if (condval_18 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_19; + if ((mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides == NULL)) { + condval_19 = 1; + } else { + condval_19 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_19); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_65; + result_65.type_index = kTVMFFINone; + result_65.zero_padding = 0; + result_65.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_65) != 0) { + return -1; + } + } + int32_t condval_20; + if ((mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides == NULL)) { + condval_20 = 1; + } else { + condval_20 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides)[0]); + } + if ((condval_20 != 16) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_66; + result_66.type_index = kTVMFFINone; + result_66.zero_padding = 0; + result_66.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_66) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)comb_mix)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_67; + result_67.type_index = kTVMFFINone; + result_67.zero_padding = 0; + result_67.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_67) != 0) { + return -1; + } + } + if ((((DLTensor*)comb_mix)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_68; + result_68.type_index = kTVMFFINone; + result_68.zero_padding = 0; + result_68.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_68) != 0) { + return -1; + } + } + if ((((DLTensor*)comb_mix)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_69; + result_69.type_index = kTVMFFINone; + result_69.zero_padding = 0; + result_69.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_69) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (comb_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_70; + result_70.type_index = kTVMFFINone; + result_70.zero_padding = 0; + result_70.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_70) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)layer_input)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)layer_input)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)layer_input)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_71; + result_71.type_index = kTVMFFINone; + result_71.zero_padding = 0; + result_71.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_71) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_72; + result_72.type_index = kTVMFFINone; + result_72.zero_padding = 0; + result_72.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_72) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[1]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_73; + result_73.type_index = kTVMFFINone; + result_73.zero_padding = 0; + result_73.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_73) != 0) { + return -1; + } + } + int32_t condval_21; + if ((mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides == NULL)) { + condval_21 = 1; + } else { + condval_21 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides)[1]); + } + if (condval_21 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_22; + if ((mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides == NULL)) { + condval_22 = 1; + } else { + condval_22 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_22); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_74; + result_74.type_index = kTVMFFINone; + result_74.zero_padding = 0; + result_74.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_74) != 0) { + return -1; + } + } + int32_t condval_23; + if ((mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides == NULL)) { + condval_23 = 1; + } else { + condval_23 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides)[0]); + } + if ((condval_23 != 4096) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_75; + result_75.type_index = kTVMFFINone; + result_75.zero_padding = 0; + result_75.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_75) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)layer_input)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_76; + result_76.type_index = kTVMFFINone; + result_76.zero_padding = 0; + result_76.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_76) != 0) { + return -1; + } + } + if ((((DLTensor*)layer_input)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_77; + result_77.type_index = kTVMFFINone; + result_77.zero_padding = 0; + result_77.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_77) != 0) { + return -1; + } + } + if ((((DLTensor*)layer_input)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_78; + result_78.type_index = kTVMFFINone; + result_78.zero_padding = 0; + result_78.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_78) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (layer_input_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_79; + result_79.type_index = kTVMFFINone; + result_79.zero_padding = 0; + result_79.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_79) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)norm_weight)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)norm_weight)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)norm_weight)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_80; + result_80.type_index = kTVMFFINone; + result_80.zero_padding = 0; + result_80.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_80) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_shape)[0]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_81; + result_81.type_index = kTVMFFINone; + result_81.zero_padding = 0; + result_81.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_81) != 0) { + return -1; + } + } + int32_t condval_24; + if ((mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides == NULL)) { + condval_24 = 1; + } else { + condval_24 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides)[0]); + } + if (condval_24 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_25; + if ((mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides == NULL)) { + condval_25 = 1; + } else { + condval_25 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides)[0]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_25); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_82; + result_82.type_index = kTVMFFINone; + result_82.zero_padding = 0; + result_82.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_82) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)norm_weight)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_83; + result_83.type_index = kTVMFFINone; + result_83.zero_padding = 0; + result_83.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_83) != 0) { + return -1; + } + } + if ((((DLTensor*)norm_weight)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_84; + result_84.type_index = kTVMFFINone; + result_84.zero_padding = 0; + result_84.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_84) != 0) { + return -1; + } + } + if ((((DLTensor*)norm_weight)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_85; + result_85.type_index = kTVMFFINone; + result_85.zero_padding = 0; + result_85.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_85) != 0) { + return -1; + } + } + if (norm_weight_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_86; + result_86.type_index = kTVMFFINone; + result_86.zero_padding = 0; + result_86.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_86) != 0) { + return -1; + } + } + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = ((int64_t)2); + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = ((int64_t)dev_id); + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + if (__tvm_set_device_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_set_device", &__tvm_set_device_packed) != 0) { + return -1; + } + } + TVMFFIAny result_87; + result_87.type_index = kTVMFFINone; + result_87.zero_padding = 0; + result_87.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_set_device_packed, (TVMFFIAny*) stack_ffi_any, 2, &result_87) != 0) { + return -1; + } + if (comb_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = comb_mix_1; + if (gemm_out_mul_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = gemm_out_mul_1; + if (gemm_out_sqrsum_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = gemm_out_sqrsum_1; + if (hc_base_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_ptr) = hc_base_1; + if (hc_scale_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_ptr) = hc_scale_1; + if (layer_input_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_ptr) = layer_input_1; + if (norm_weight_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_ptr) = norm_weight_1; + if (post_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_ptr) = post_mix_1; + if (residual_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_ptr) = residual_1; + (((TVMFFIAny*)stack_ffi_any)[9].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[9].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[9].v_int64) = ((int64_t)num_tokens); + (((TVMFFIAny*)stack_ffi_any)[10].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[10].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[10].v_int64) = ((int64_t)num_tokens); + (((TVMFFIAny*)stack_ffi_any)[11].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[11].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[11].v_int64) = ((int64_t)96); + (((TVMFFIAny*)stack_ffi_any)[12].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[12].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[12].v_int64) = ((int64_t)1); + (((TVMFFIAny*)stack_ffi_any)[13].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[13].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[13].v_int64) = ((int64_t)1); + (((TVMFFIAny*)stack_ffi_any)[14].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[14].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[14].v_int64) = ((int64_t)29040); + (((TVMFFIAny*)stack_ffi_any)[15].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[15].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[15].v_int64) = (int64_t)0; + if (mhc_pre_big_fuse_with_norm_tilelang_kernel_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "mhc_pre_big_fuse_with_norm_tilelang_kernel", &mhc_pre_big_fuse_with_norm_tilelang_kernel_packed) != 0) { + return -1; + } + } + TVMFFIAny result_88; + result_88.type_index = kTVMFFINone; + result_88.zero_padding = 0; + result_88.v_int64 = 0; + if (TVMFFIFunctionCall(mhc_pre_big_fuse_with_norm_tilelang_kernel_packed, (TVMFFIAny*) stack_ffi_any, 15, &result_88) != 0) { + return -1; + } + return 0; +} + +// CodegenC: NOTE: Auto-generated entry function +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_main(void* self, void* args,int num_args, void* result) { + return __tvm_ffi_mhc_pre_big_fuse_with_norm_tilelang(self, args, num_args, result); +} diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/1f417b351704372ae9697b314cec4913d9e69469d246e2c9d2c8400a16396625/params.pkl b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/1f417b351704372ae9697b314cec4913d9e69469d246e2c9d2c8400a16396625/params.pkl new file mode 100644 index 0000000..715ab64 Binary files /dev/null and b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/1f417b351704372ae9697b314cec4913d9e69469d246e2c9d2c8400a16396625/params.pkl differ diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/1f58ab0397f1bec57393c246b40519995302f81a4f075621dbc500f561f77d46/device_kernel.cu b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/1f58ab0397f1bec57393c246b40519995302f81a4f075621dbc500f561f77d46/device_kernel.cu new file mode 100644 index 0000000..6c55a01 --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/1f58ab0397f1bec57393c246b40519995302f81a4f075621dbc500f561f77d46/device_kernel.cu @@ -0,0 +1,424 @@ +#include +#include +#include +#include +#include +#include +#include +#ifdef ENABLE_BF16 +#include +#endif + +extern "C" __global__ void mhc_pre_big_fuse_with_norm_tilelang_kernel(float* comb_mix, const float* gemm_out_mul, const float* gemm_out_sqrsum, const float* hc_base, const float* hc_scale, bfloat16_t* layer_input, const bfloat16_t* norm_weight, float* post_mix, const bfloat16_t* residual, int num_tokens); +extern "C" __global__ void __launch_bounds__(96, 1) mhc_pre_big_fuse_with_norm_tilelang_kernel(float* comb_mix, const float* gemm_out_mul, const float* gemm_out_sqrsum, const float* hc_base, const float* hc_scale, bfloat16_t* layer_input, const bfloat16_t* norm_weight, float* post_mix, const bfloat16_t* residual, int num_tokens) { + extern __shared__ __align__(1024) uchar buf_dyn_shmem[]; + float mixes[1]; + float rms[1]; + float cm[1]; + float row_max[1]; + float row_sum[1]; + float col_sum[1]; + float sumsq_per_pos[16]; + float sumsq[1]; + float rsqrt_norm[1]; + float xl[64]; + float ol[16]; + bfloat16_t xs_local_cast[8]; + bfloat16_t xs_local_cast_1[8]; + bfloat16_t xs_local_cast_2[8]; + float w_local[16]; + float ol_1[16]; + bfloat16_t w_shared_local_cast_3[8]; + bfloat16_t output_shared_local_cast_4[8]; + bfloat16_t layer_input_local_cast_5[8]; + bfloat16_t w_shared_local_cast_6[8]; + bfloat16_t output_shared_local_cast_7[8]; + bfloat16_t layer_input_local_cast_8[8]; + bfloat16_t w_shared_local_cast_9[8]; + bfloat16_t output_shared_local_cast_10[8]; + bfloat16_t layer_input_local_cast_11[8]; + mixes[0] = 0x0p+0f/*0.000000e+00*/; + rms[0] = 0x0p+0f/*0.000000e+00*/; + cudaGridDependencySynchronize(); + for (int i_split = 0; i_split < 15; ++i_split) { + rms[0] = (rms[0] + gemm_out_sqrsum[((((int64_t)i_split) * ((int64_t)num_tokens)) + ((int64_t)((int)blockIdx.x)))]); + } + rms[0] = rsqrtf(((rms[0] / 0x1p+14f/*1.638400e+04*/) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + mixes[0] = 0x0p+0f/*0.000000e+00*/; + for (int i_split_1 = 0; i_split_1 < 15; ++i_split_1) { + mixes[0] = (mixes[0] + gemm_out_mul[(((((int64_t)((int)blockIdx.x)) * (int64_t)24) + ((((int64_t)i_split_1) * ((int64_t)num_tokens)) * (int64_t)24)) + (((int64_t)((int)threadIdx.x)) % (int64_t)24))]); + } + mixes[0] = (mixes[0] * rms[0]); + if ((((int)threadIdx.x) / 24) == 0) { + ((float*)buf_dyn_shmem)[(((int)threadIdx.x) % 24)] = mixes[0]; + } + __syncthreads(); + if (((int)threadIdx.x) < 32) { + if (((int)threadIdx.x) < 4) { + post_mix[((((int64_t)((int)blockIdx.x)) * (int64_t)4) + ((int64_t)((int)threadIdx.x)))] = ((0x1p+0f/*1.000000e+00*/ / (0x1p+0f/*1.000000e+00*/ + expf((0x0p+0f/*0.000000e+00*/ - ((((float*)buf_dyn_shmem)[(((int)threadIdx.x) + 4)] * hc_scale[1]) + hc_base[(((int)threadIdx.x) + 4)]))))) * 0x1p+1f/*2.000000e+00*/); + } + cm[0] = ((((float*)buf_dyn_shmem)[((((int)threadIdx.x) & 15) + 8)] * hc_scale[2]) + hc_base[((((int)threadIdx.x) & 15) + 8)]); + row_max[0] = -CUDART_INF_F; + row_max[0] = max(row_max[0], cm[0]); + row_max[0] = tl::AllReduce>::run(row_max[0]); + cm[0] = expf((cm[0] - row_max[0])); + row_sum[0] = 0x0p+0f/*0.000000e+00*/; + row_sum[0] = (row_sum[0] + cm[0]); + row_sum[0] = tl::AllReduce>::run(row_sum[0]); + cm[0] = ((cm[0] / row_sum[0]) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/); + col_sum[0] = 0x0p+0f/*0.000000e+00*/; + col_sum[0] = (col_sum[0] + cm[0]); + col_sum[0] = tl::AllReduce>::run(col_sum[0]); + cm[0] = (cm[0] / (col_sum[0] + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + for (int __1 = 0; __1 < 19; ++__1) { + row_sum[0] = 0x0p+0f/*0.000000e+00*/; + row_sum[0] = (row_sum[0] + cm[0]); + row_sum[0] = tl::AllReduce>::run(row_sum[0]); + cm[0] = (cm[0] / (row_sum[0] + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + col_sum[0] = 0x0p+0f/*0.000000e+00*/; + col_sum[0] = (col_sum[0] + cm[0]); + col_sum[0] = tl::AllReduce>::run(col_sum[0]); + cm[0] = (cm[0] / (col_sum[0] + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + } + if ((((int)threadIdx.x) >> 4) == 0) { + comb_mix[((((int64_t)((int)blockIdx.x)) * (int64_t)16) + (((int64_t)((int)threadIdx.x)) & (int64_t)15))] = cm[0]; + } + } else { + if (((int)threadIdx.x) < 36) { + ((float*)buf_dyn_shmem)[(((int)threadIdx.x) + 7224)] = ((0x1p+0f/*1.000000e+00*/ / (0x1p+0f/*1.000000e+00*/ + expf((0x0p+0f/*0.000000e+00*/ - ((((float*)buf_dyn_shmem)[(((int)threadIdx.x) - 32)] * hc_scale[0]) + hc_base[(((int)threadIdx.x) - 32)]))))) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/); + } + #pragma unroll + for (int i = 0; i < 4; ++i) { + float broadcast_var = 0x0p+0f/*0.000000e+00*/; + *(float4*)(sumsq_per_pos + (i * 4)) = make_float4(broadcast_var, broadcast_var, broadcast_var, broadcast_var); + } + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_1 = 0; i_1 < 8; ++i_1) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i_1 >> 1) * 1024) + (((((i_1 * 64) + ((int)threadIdx.x)) + 96) & 127) * 8)) + 48)])), (&(residual[(((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + ((((int64_t)i_1) >> (int64_t)1) * (int64_t)4096)) + (((((((int64_t)i_1) * (int64_t)64) + ((int64_t)((int)threadIdx.x))) + (int64_t)96) & (int64_t)127) * (int64_t)8))]))); + } + tl::cp_async_commit(); + #pragma unroll + for (int i_2 = 0; i_2 < 8; ++i_2) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i_2 >> 1) * 1024) + (((((i_2 * 64) + ((int)threadIdx.x)) + 96) & 127) * 8)) + 4144)])), (&(residual[((((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + ((((int64_t)i_2) >> (int64_t)1) * (int64_t)4096)) + (((((((int64_t)i_2) * (int64_t)64) + ((int64_t)((int)threadIdx.x))) + (int64_t)96) & (int64_t)127) * (int64_t)8)) + (int64_t)1024)]))); + } + tl::cp_async_commit(); + for (int i0_h = 0; i0_h < 2; ++i0_h) { + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_3 = 0; i_3 < 8; ++i_3) { + *(uint4*)(xs_local_cast + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + ((((i0_h * 4096) + (i_3 * 512)) + (((int)threadIdx.x) * 8)) - 208)); + for (int vec = 0; vec < 2; ++vec) { + float4 __2; + uint2 v_ = *(uint2*)(xs_local_cast + (vec * 4)); + ((float2*)(&__2))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v_))[0]); + ((float2*)(&__2))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v_))[1]); + *(float4*)(xl + ((i_3 * 8) + (vec * 4))) = __2; + } + } + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_4 = 0; i_4 < 8; ++i_4) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i0_h * 4096) + ((i_4 >> 1) * 1024)) + (((((i_4 * 64) + ((int)threadIdx.x)) + 96) & 127) * 8)) + 48)])), (&(residual[(((((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + ((((int64_t)i_4) >> (int64_t)1) * (int64_t)4096)) + (((int64_t)i0_h) * (int64_t)1024)) + (((((((int64_t)i_4) * (int64_t)64) + ((int64_t)((int)threadIdx.x))) + (int64_t)96) & (int64_t)127) * (int64_t)8)) + (int64_t)2048)]))); + } + tl::cp_async_commit(); + #pragma unroll + for (int i_5 = 0; i_5 < 4; ++i_5) { + float broadcast_var_1 = 0x0p+0f/*0.000000e+00*/; + *(float4*)(ol + (i_5 * 4)) = make_float4(broadcast_var_1, broadcast_var_1, broadcast_var_1, broadcast_var_1); + } + tl::__sync_thread_partial<3, 64>(); + for (int i_hc = 0; i_hc < 4; ++i_hc) { + float pre = ((float*)buf_dyn_shmem)[(i_hc + 7256)]; + #pragma unroll + for (int i_6 = 0; i_6 < 16; ++i_6) { + ol[i_6] = (ol[i_6] + (pre * xl[((i_hc * 16) + i_6)])); + } + } + #pragma unroll + for (int i_7 = 0; i_7 < 4; ++i_7) { + float4 __3; + float4 v__1 = *(float4*)(sumsq_per_pos + (i_7 * 4)); + float4 __4; + float4 v__2 = *(float4*)(ol + (i_7 * 4)); + __4.x = (v__2.x*v__2.x); + __4.y = (v__2.y*v__2.y); + __4.z = (v__2.z*v__2.z); + __4.w = (v__2.w*v__2.w); + __3.x = (v__1.x+__4.x); + __3.y = (v__1.y+__4.y); + __3.z = (v__1.z+__4.z); + __3.w = (v__1.w+__4.w); + *(float4*)(sumsq_per_pos + (i_7 * 4)) = __3; + uint2 __5; + float4 v__3 = *(float4*)(ol + (i_7 * 4)); + (reinterpret_cast<__nv_bfloat162*>(&__5))[0] = __float22bfloat162_rn(((float2*)(&v__3))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__5))[1] = __float22bfloat162_rn(((float2*)(&v__3))[1]); + *(uint2*)(((bfloat16_t*)buf_dyn_shmem) + (((((i0_h * 1024) + ((i_7 >> 1) * 512)) + (((int)threadIdx.x) * 8)) + ((i_7 & 1) * 4)) + 7984)) = __5; + } + } + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_8 = 0; i_8 < 8; ++i_8) { + *(uint4*)(xs_local_cast_1 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_8 * 512) + (((int)threadIdx.x) * 8)) - 208)); + for (int vec_1 = 0; vec_1 < 2; ++vec_1) { + float4 __6; + uint2 v__4 = *(uint2*)(xs_local_cast_1 + (vec_1 * 4)); + ((float2*)(&__6))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__4))[0]); + ((float2*)(&__6))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__4))[1]); + *(float4*)(xl + ((i_8 * 8) + (vec_1 * 4))) = __6; + } + } + #pragma unroll + for (int i_9 = 0; i_9 < 4; ++i_9) { + float broadcast_var_2 = 0x0p+0f/*0.000000e+00*/; + *(float4*)(ol + (i_9 * 4)) = make_float4(broadcast_var_2, broadcast_var_2, broadcast_var_2, broadcast_var_2); + } + for (int i_hc_1 = 0; i_hc_1 < 4; ++i_hc_1) { + float pre_1 = ((float*)buf_dyn_shmem)[(i_hc_1 + 7256)]; + #pragma unroll + for (int i_10 = 0; i_10 < 16; ++i_10) { + ol[i_10] = (ol[i_10] + (pre_1 * xl[((i_hc_1 * 16) + i_10)])); + } + } + #pragma unroll + for (int i_11 = 0; i_11 < 4; ++i_11) { + float4 __7; + float4 v__5 = *(float4*)(sumsq_per_pos + (i_11 * 4)); + float4 __8; + float4 v__6 = *(float4*)(ol + (i_11 * 4)); + __8.x = (v__6.x*v__6.x); + __8.y = (v__6.y*v__6.y); + __8.z = (v__6.z*v__6.z); + __8.w = (v__6.w*v__6.w); + __7.x = (v__5.x+__8.x); + __7.y = (v__5.y+__8.y); + __7.z = (v__5.z+__8.z); + __7.w = (v__5.w+__8.w); + *(float4*)(sumsq_per_pos + (i_11 * 4)) = __7; + uint2 __9; + float4 v__7 = *(float4*)(ol + (i_11 * 4)); + (reinterpret_cast<__nv_bfloat162*>(&__9))[0] = __float22bfloat162_rn(((float2*)(&v__7))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__9))[1] = __float22bfloat162_rn(((float2*)(&v__7))[1]); + *(uint2*)(((bfloat16_t*)buf_dyn_shmem) + (((((i_11 >> 1) * 512) + (((int)threadIdx.x) * 8)) + ((i_11 & 1) * 4)) + 10032)) = __9; + } + tl::cp_async_wait<0>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_12 = 0; i_12 < 8; ++i_12) { + *(uint4*)(xs_local_cast_2 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_12 * 512) + (((int)threadIdx.x) * 8)) + 3888)); + for (int vec_2 = 0; vec_2 < 2; ++vec_2) { + float4 __10; + uint2 v__8 = *(uint2*)(xs_local_cast_2 + (vec_2 * 4)); + ((float2*)(&__10))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__8))[0]); + ((float2*)(&__10))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__8))[1]); + *(float4*)(xl + ((i_12 * 8) + (vec_2 * 4))) = __10; + } + } + #pragma unroll + for (int i_13 = 0; i_13 < 4; ++i_13) { + float broadcast_var_3 = 0x0p+0f/*0.000000e+00*/; + *(float4*)(ol + (i_13 * 4)) = make_float4(broadcast_var_3, broadcast_var_3, broadcast_var_3, broadcast_var_3); + } + for (int i_hc_2 = 0; i_hc_2 < 4; ++i_hc_2) { + float pre_2 = ((float*)buf_dyn_shmem)[(i_hc_2 + 7256)]; + #pragma unroll + for (int i_14 = 0; i_14 < 16; ++i_14) { + ol[i_14] = (ol[i_14] + (pre_2 * xl[((i_hc_2 * 16) + i_14)])); + } + } + #pragma unroll + for (int i_15 = 0; i_15 < 4; ++i_15) { + float4 __11; + float4 v__9 = *(float4*)(sumsq_per_pos + (i_15 * 4)); + float4 __12; + float4 v__10 = *(float4*)(ol + (i_15 * 4)); + __12.x = (v__10.x*v__10.x); + __12.y = (v__10.y*v__10.y); + __12.z = (v__10.z*v__10.z); + __12.w = (v__10.w*v__10.w); + __11.x = (v__9.x+__12.x); + __11.y = (v__9.y+__12.y); + __11.z = (v__9.z+__12.z); + __11.w = (v__9.w+__12.w); + *(float4*)(sumsq_per_pos + (i_15 * 4)) = __11; + uint2 __13; + float4 v__11 = *(float4*)(ol + (i_15 * 4)); + (reinterpret_cast<__nv_bfloat162*>(&__13))[0] = __float22bfloat162_rn(((float2*)(&v__11))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__13))[1] = __float22bfloat162_rn(((float2*)(&v__11))[1]); + *(uint2*)(((bfloat16_t*)buf_dyn_shmem) + (((((i_15 >> 1) * 512) + (((int)threadIdx.x) * 8)) + ((i_15 & 1) * 4)) + 11056)) = __13; + } + sumsq[0] = 0x0p+0f/*0.000000e+00*/; + #pragma unroll + for (int rv = 0; rv < 16; ++rv) { + sumsq[0] = (sumsq[0] + sumsq_per_pos[(((rv & 1) * 8) + (rv >> 1))]); + } + tl::__sync_thread_partial<3, 64>(); + sumsq[0] = tl::AllReduce>::run(sumsq[0], (&(((float*)buf_dyn_shmem)[7192]))); + rsqrt_norm[0] = rsqrtf(((sumsq[0] / 0x1p+12f/*4.096000e+03*/) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + #pragma unroll + for (int i_16 = 0; i_16 < 2; ++i_16) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[(((i_16 * 512) + (((int)threadIdx.x) * 8)) + 12080)])), (&(norm_weight[(((i_16 * 512) + (((int)threadIdx.x) * 8)) - 256)]))); + } + tl::cp_async_commit(); + #pragma unroll + for (int i_17 = 0; i_17 < 2; ++i_17) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[(((i_17 * 512) + (((int)threadIdx.x) * 8)) + 13104)])), (&(norm_weight[(((i_17 * 512) + (((int)threadIdx.x) * 8)) + 768)]))); + } + tl::cp_async_commit(); + for (int i0_h_1 = 0; i0_h_1 < 2; ++i0_h_1) { + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_18 = 0; i_18 < 2; ++i_18) { + *(uint4*)(w_shared_local_cast_3 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + ((((i0_h_1 * 1024) + (i_18 * 512)) + (((int)threadIdx.x) * 8)) + 12080)); + for (int vec_3 = 0; vec_3 < 2; ++vec_3) { + float4 __14; + uint2 v__12 = *(uint2*)(w_shared_local_cast_3 + (vec_3 * 4)); + ((float2*)(&__14))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__12))[0]); + ((float2*)(&__14))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__12))[1]); + *(float4*)(w_local + ((i_18 * 8) + (vec_3 * 4))) = __14; + } + } + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_19 = 0; i_19 < 2; ++i_19) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i0_h_1 * 1024) + (i_19 * 512)) + (((int)threadIdx.x) * 8)) + 12080)])), (&(norm_weight[((((i0_h_1 * 1024) + (i_19 * 512)) + (((int)threadIdx.x) * 8)) + 1792)]))); + } + tl::cp_async_commit(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_20 = 0; i_20 < 2; ++i_20) { + *(uint4*)(output_shared_local_cast_4 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + ((((i0_h_1 * 1024) + (i_20 * 512)) + (((int)threadIdx.x) * 8)) + 7984)); + for (int vec_4 = 0; vec_4 < 2; ++vec_4) { + float4 __15; + float4 __16; + float4 __17; + uint2 v__13 = *(uint2*)(output_shared_local_cast_4 + (vec_4 * 4)); + ((float2*)(&__17))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__13))[0]); + ((float2*)(&__17))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__13))[1]); + float4 v__14 = make_float4(rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0]); + __16.x = (__17.x*v__14.x); + __16.y = (__17.y*v__14.y); + __16.z = (__17.z*v__14.z); + __16.w = (__17.w*v__14.w); + float4 v__15 = *(float4*)(w_local + ((i_20 * 8) + (vec_4 * 4))); + __15.x = (__16.x*v__15.x); + __15.y = (__16.y*v__15.y); + __15.z = (__16.z*v__15.z); + __15.w = (__16.w*v__15.w); + *(float4*)(ol_1 + ((i_20 * 8) + (vec_4 * 4))) = __15; + } + } + #pragma unroll + for (int i_21 = 0; i_21 < 2; ++i_21) { + for (int vec_5 = 0; vec_5 < 2; ++vec_5) { + uint2 __18; + float4 v__16 = *(float4*)(ol_1 + ((i_21 * 8) + (vec_5 * 4))); + (reinterpret_cast<__nv_bfloat162*>(&__18))[0] = __float22bfloat162_rn(((float2*)(&v__16))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__18))[1] = __float22bfloat162_rn(((float2*)(&v__16))[1]); + *(uint2*)(layer_input_local_cast_5 + (vec_5 * 4)) = __18; + } + *(uint4*)(layer_input + (((((((int64_t)((int)blockIdx.x)) * (int64_t)4096) + (((int64_t)i0_h_1) * (int64_t)1024)) + (((int64_t)i_21) * (int64_t)512)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8)) - (int64_t)256)) = *(uint4*)(layer_input_local_cast_5 + 0); + } + } + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_22 = 0; i_22 < 2; ++i_22) { + *(uint4*)(w_shared_local_cast_6 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_22 * 512) + (((int)threadIdx.x) * 8)) + 12080)); + for (int vec_6 = 0; vec_6 < 2; ++vec_6) { + float4 __19; + uint2 v__17 = *(uint2*)(w_shared_local_cast_6 + (vec_6 * 4)); + ((float2*)(&__19))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__17))[0]); + ((float2*)(&__19))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__17))[1]); + *(float4*)(w_local + ((i_22 * 8) + (vec_6 * 4))) = __19; + } + } + #pragma unroll + for (int i_23 = 0; i_23 < 2; ++i_23) { + *(uint4*)(output_shared_local_cast_7 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_23 * 512) + (((int)threadIdx.x) * 8)) + 10032)); + for (int vec_7 = 0; vec_7 < 2; ++vec_7) { + float4 __20; + float4 __21; + float4 __22; + uint2 v__18 = *(uint2*)(output_shared_local_cast_7 + (vec_7 * 4)); + ((float2*)(&__22))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__18))[0]); + ((float2*)(&__22))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__18))[1]); + float4 v__19 = make_float4(rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0]); + __21.x = (__22.x*v__19.x); + __21.y = (__22.y*v__19.y); + __21.z = (__22.z*v__19.z); + __21.w = (__22.w*v__19.w); + float4 v__20 = *(float4*)(w_local + ((i_23 * 8) + (vec_7 * 4))); + __20.x = (__21.x*v__20.x); + __20.y = (__21.y*v__20.y); + __20.z = (__21.z*v__20.z); + __20.w = (__21.w*v__20.w); + *(float4*)(ol_1 + ((i_23 * 8) + (vec_7 * 4))) = __20; + } + } + #pragma unroll + for (int i_24 = 0; i_24 < 2; ++i_24) { + for (int vec_8 = 0; vec_8 < 2; ++vec_8) { + uint2 __23; + float4 v__21 = *(float4*)(ol_1 + ((i_24 * 8) + (vec_8 * 4))); + (reinterpret_cast<__nv_bfloat162*>(&__23))[0] = __float22bfloat162_rn(((float2*)(&v__21))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__23))[1] = __float22bfloat162_rn(((float2*)(&v__21))[1]); + *(uint2*)(layer_input_local_cast_8 + (vec_8 * 4)) = __23; + } + *(uint4*)(layer_input + ((((((int64_t)((int)blockIdx.x)) * (int64_t)4096) + (((int64_t)i_24) * (int64_t)512)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8)) + (int64_t)1792)) = *(uint4*)(layer_input_local_cast_8 + 0); + } + tl::cp_async_wait<0>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_25 = 0; i_25 < 2; ++i_25) { + *(uint4*)(w_shared_local_cast_9 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_25 * 512) + (((int)threadIdx.x) * 8)) + 13104)); + for (int vec_9 = 0; vec_9 < 2; ++vec_9) { + float4 __24; + uint2 v__22 = *(uint2*)(w_shared_local_cast_9 + (vec_9 * 4)); + ((float2*)(&__24))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__22))[0]); + ((float2*)(&__24))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__22))[1]); + *(float4*)(w_local + ((i_25 * 8) + (vec_9 * 4))) = __24; + } + } + #pragma unroll + for (int i_26 = 0; i_26 < 2; ++i_26) { + *(uint4*)(output_shared_local_cast_10 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_26 * 512) + (((int)threadIdx.x) * 8)) + 11056)); + for (int vec_10 = 0; vec_10 < 2; ++vec_10) { + float4 __25; + float4 __26; + float4 __27; + uint2 v__23 = *(uint2*)(output_shared_local_cast_10 + (vec_10 * 4)); + ((float2*)(&__27))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__23))[0]); + ((float2*)(&__27))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__23))[1]); + float4 v__24 = make_float4(rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0]); + __26.x = (__27.x*v__24.x); + __26.y = (__27.y*v__24.y); + __26.z = (__27.z*v__24.z); + __26.w = (__27.w*v__24.w); + float4 v__25 = *(float4*)(w_local + ((i_26 * 8) + (vec_10 * 4))); + __25.x = (__26.x*v__25.x); + __25.y = (__26.y*v__25.y); + __25.z = (__26.z*v__25.z); + __25.w = (__26.w*v__25.w); + *(float4*)(ol_1 + ((i_26 * 8) + (vec_10 * 4))) = __25; + } + } + #pragma unroll + for (int i_27 = 0; i_27 < 2; ++i_27) { + for (int vec_11 = 0; vec_11 < 2; ++vec_11) { + uint2 __28; + float4 v__26 = *(float4*)(ol_1 + ((i_27 * 8) + (vec_11 * 4))); + (reinterpret_cast<__nv_bfloat162*>(&__28))[0] = __float22bfloat162_rn(((float2*)(&v__26))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__28))[1] = __float22bfloat162_rn(((float2*)(&v__26))[1]); + *(uint2*)(layer_input_local_cast_11 + (vec_11 * 4)) = __28; + } + *(uint4*)(layer_input + ((((((int64_t)((int)blockIdx.x)) * (int64_t)4096) + (((int64_t)i_27) * (int64_t)512)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8)) + (int64_t)2816)) = *(uint4*)(layer_input_local_cast_11 + 0); + } + } + cudaTriggerProgrammaticLaunchCompletion(); +} + diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/1f58ab0397f1bec57393c246b40519995302f81a4f075621dbc500f561f77d46/host_kernel.cu b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/1f58ab0397f1bec57393c246b40519995302f81a4f075621dbc500f561f77d46/host_kernel.cu new file mode 100644 index 0000000..e209611 --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/1f58ab0397f1bec57393c246b40519995302f81a4f075621dbc500f561f77d46/host_kernel.cu @@ -0,0 +1,3359 @@ +// tilelang target: c -keys=cpu +#define TVM_EXPORTS +#include "tvm/runtime/base.h" +#include "tvm/runtime/c_backend_api.h" +#include "tvm/ffi/c_api.h" +#include +#include +#include +#ifdef __OBJC__ +#include "tvm/runtime/device_api.h" +#include "tvm/ffi/function.h" +#include +#include +#include +#endif +void* __tvm_ffi__library_ctx = NULL; +static void* __tvm_error_ndim_mismatch_packed = NULL; +static void* __tvm_error_dtype_mismatch_packed = NULL; +static void* __tvm_error_expect_eq_packed = NULL; +static void* __tvm_error_constraint_violation_packed = NULL; +static void* __tvm_error_byte_offset_mismatch_packed = NULL; +static void* __tvm_error_device_type_mismatch_packed = NULL; +static void* __tvm_error_null_ptr_packed = NULL; +static void* __tvm_set_device_packed = NULL; +static void* mhc_pre_big_fuse_with_norm_tilelang_kernel_packed = NULL; +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_mhc_pre_big_fuse_with_norm_tilelang(void* self_handle, void* args, int32_t num_args, void* result); +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_mhc_pre_big_fuse_with_norm_tilelang(void* self_handle, void* args, int32_t num_args, void* result) { + __attribute__((aligned(64))) TVMFFIAny stack[16]; + void* stack_ffi_any = stack; + if (!((num_args == 9))) { + char __tvm_assert_msg_buf[512]; + snprintf(__tvm_assert_msg_buf, 512, "%s; expected: %lld, got: %lld", "mhc_pre_big_fuse_with_norm_tilelang: num_args should be 9", (long long)(num_args), (long long)(9)); + TVMFFIErrorSetRaisedFromCStr("RuntimeError", __tvm_assert_msg_buf); + return -1; + } + if (!(!(args == NULL))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang: args pointer is NULL"); + return -1; + } + int32_t gemm_out_mul_type_index = (((TVMFFIAny*)args)[0].type_index); + if (!(((((gemm_out_mul_type_index == 0) || (gemm_out_mul_type_index == 4)) || (gemm_out_mul_type_index == 7)) || (64 <= gemm_out_mul_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input gemm_out_mul expected pointer or tensor handle"); + return -1; + } + int32_t gemm_out_sqrsum_type_index = (((TVMFFIAny*)args)[1].type_index); + if (!(((((gemm_out_sqrsum_type_index == 0) || (gemm_out_sqrsum_type_index == 4)) || (gemm_out_sqrsum_type_index == 7)) || (64 <= gemm_out_sqrsum_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input gemm_out_sqrsum expected pointer or tensor handle"); + return -1; + } + int32_t hc_scale_type_index = (((TVMFFIAny*)args)[2].type_index); + if (!(((((hc_scale_type_index == 0) || (hc_scale_type_index == 4)) || (hc_scale_type_index == 7)) || (64 <= hc_scale_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input hc_scale expected pointer or tensor handle"); + return -1; + } + int32_t hc_base_type_index = (((TVMFFIAny*)args)[3].type_index); + if (!(((((hc_base_type_index == 0) || (hc_base_type_index == 4)) || (hc_base_type_index == 7)) || (64 <= hc_base_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input hc_base expected pointer or tensor handle"); + return -1; + } + int32_t residual_type_index = (((TVMFFIAny*)args)[4].type_index); + if (!(((((residual_type_index == 0) || (residual_type_index == 4)) || (residual_type_index == 7)) || (64 <= residual_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input residual expected pointer or tensor handle"); + return -1; + } + int32_t post_mix_type_index = (((TVMFFIAny*)args)[5].type_index); + if (!(((((post_mix_type_index == 0) || (post_mix_type_index == 4)) || (post_mix_type_index == 7)) || (64 <= post_mix_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input post_mix expected pointer or tensor handle"); + return -1; + } + int32_t comb_mix_type_index = (((TVMFFIAny*)args)[6].type_index); + if (!(((((comb_mix_type_index == 0) || (comb_mix_type_index == 4)) || (comb_mix_type_index == 7)) || (64 <= comb_mix_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input comb_mix expected pointer or tensor handle"); + return -1; + } + int32_t layer_input_type_index = (((TVMFFIAny*)args)[7].type_index); + if (!(((((layer_input_type_index == 0) || (layer_input_type_index == 4)) || (layer_input_type_index == 7)) || (64 <= layer_input_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input layer_input expected pointer or tensor handle"); + return -1; + } + int32_t norm_weight_type_index = (((TVMFFIAny*)args)[8].type_index); + if (!(((((norm_weight_type_index == 0) || (norm_weight_type_index == 4)) || (norm_weight_type_index == 7)) || (64 <= norm_weight_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input norm_weight expected pointer or tensor handle"); + return -1; + } + void* gemm_out_mul = ((gemm_out_mul_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[0].v_ptr) + 24)) : (((TVMFFIAny*)args)[0].v_ptr)); + void* gemm_out_sqrsum = ((gemm_out_sqrsum_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[1].v_ptr) + 24)) : (((TVMFFIAny*)args)[1].v_ptr)); + void* hc_scale = ((hc_scale_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[2].v_ptr) + 24)) : (((TVMFFIAny*)args)[2].v_ptr)); + void* hc_base = ((hc_base_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[3].v_ptr) + 24)) : (((TVMFFIAny*)args)[3].v_ptr)); + void* residual = ((residual_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[4].v_ptr) + 24)) : (((TVMFFIAny*)args)[4].v_ptr)); + void* post_mix = ((post_mix_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[5].v_ptr) + 24)) : (((TVMFFIAny*)args)[5].v_ptr)); + void* comb_mix = ((comb_mix_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[6].v_ptr) + 24)) : (((TVMFFIAny*)args)[6].v_ptr)); + void* layer_input = ((layer_input_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[7].v_ptr) + 24)) : (((TVMFFIAny*)args)[7].v_ptr)); + void* norm_weight = ((norm_weight_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[8].v_ptr) + 24)) : (((TVMFFIAny*)args)[8].v_ptr)); + bool mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_is_null = (gemm_out_mul == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.gemm_out_mul is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_is_null = (gemm_out_sqrsum == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.gemm_out_sqrsum is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_hc_scale_is_null = (hc_scale == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_hc_scale_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.hc_scale is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_hc_base_is_null = (hc_base == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_hc_base_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.hc_base is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_residual_is_null = (residual == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_residual_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.residual is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_post_mix_is_null = (post_mix == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_post_mix_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.post_mix is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_comb_mix_is_null = (comb_mix == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_comb_mix_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.comb_mix is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_layer_input_is_null = (layer_input == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_layer_input_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.layer_input is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_norm_weight_is_null = (norm_weight == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_norm_weight_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.norm_weight is expected to have non-NULL pointer"); + return -1; + } + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape = (((DLTensor*)gemm_out_mul)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape = (((DLTensor*)gemm_out_sqrsum)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_hc_scale_shape = (((DLTensor*)hc_scale)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_hc_base_shape = (((DLTensor*)hc_base)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_residual_shape = (((DLTensor*)residual)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape = (((DLTensor*)post_mix)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape = (((DLTensor*)comb_mix)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape = (((DLTensor*)layer_input)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_norm_weight_shape = (((DLTensor*)norm_weight)[0].shape); + if ((((DLTensor*)gemm_out_mul)[0].ndim) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_1; + result_1.type_index = kTVMFFINone; + result_1.zero_padding = 0; + result_1.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_1) != 0) { + return -1; + } + } + if (!((bool)1)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "Symbolic shape variable num_tokens requires at least one non-null buffer among: mhc_pre_big_fuse_with_norm_tilelang.gemm_out_mul, mhc_pre_big_fuse_with_norm_tilelang.gemm_out_sqrsum, mhc_pre_big_fuse_with_norm_tilelang.residual, mhc_pre_big_fuse_with_norm_tilelang.post_mix, mhc_pre_big_fuse_with_norm_tilelang.comb_mix, mhc_pre_big_fuse_with_norm_tilelang.layer_input"); + return -1; + } + int32_t num_tokens = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]); + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides = (((DLTensor*)gemm_out_mul)[0].strides); + int32_t dev_id = (((DLTensor*)gemm_out_mul)[0].device.device_id); + void* gemm_out_mul_1 = (((DLTensor*)gemm_out_mul)[0].data); + if ((((DLTensor*)gemm_out_sqrsum)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_2; + result_2.type_index = kTVMFFINone; + result_2.zero_padding = 0; + result_2.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_2) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides = (((DLTensor*)gemm_out_sqrsum)[0].strides); + void* gemm_out_sqrsum_1 = (((DLTensor*)gemm_out_sqrsum)[0].data); + if ((((DLTensor*)hc_scale)[0].ndim) != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_3; + result_3.type_index = kTVMFFINone; + result_3.zero_padding = 0; + result_3.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_3) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides = (((DLTensor*)hc_scale)[0].strides); + void* hc_scale_1 = (((DLTensor*)hc_scale)[0].data); + if ((((DLTensor*)hc_base)[0].ndim) != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_4; + result_4.type_index = kTVMFFINone; + result_4.zero_padding = 0; + result_4.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_4) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides = (((DLTensor*)hc_base)[0].strides); + void* hc_base_1 = (((DLTensor*)hc_base)[0].data); + if ((((DLTensor*)residual)[0].ndim) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_5; + result_5.type_index = kTVMFFINone; + result_5.zero_padding = 0; + result_5.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_5) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_residual_strides = (((DLTensor*)residual)[0].strides); + void* residual_1 = (((DLTensor*)residual)[0].data); + if ((((DLTensor*)post_mix)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_6; + result_6.type_index = kTVMFFINone; + result_6.zero_padding = 0; + result_6.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_6) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides = (((DLTensor*)post_mix)[0].strides); + void* post_mix_1 = (((DLTensor*)post_mix)[0].data); + if ((((DLTensor*)comb_mix)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_7; + result_7.type_index = kTVMFFINone; + result_7.zero_padding = 0; + result_7.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_7) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides = (((DLTensor*)comb_mix)[0].strides); + void* comb_mix_1 = (((DLTensor*)comb_mix)[0].data); + if ((((DLTensor*)layer_input)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_8; + result_8.type_index = kTVMFFINone; + result_8.zero_padding = 0; + result_8.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_8) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides = (((DLTensor*)layer_input)[0].strides); + void* layer_input_1 = (((DLTensor*)layer_input)[0].data); + if ((((DLTensor*)norm_weight)[0].ndim) != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_9; + result_9.type_index = kTVMFFINone; + result_9.zero_padding = 0; + result_9.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_9) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides = (((DLTensor*)norm_weight)[0].strides); + void* norm_weight_1 = (((DLTensor*)norm_weight)[0].data); + if ((((((DLTensor*)gemm_out_mul)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)gemm_out_mul)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)gemm_out_mul)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_10; + result_10.type_index = kTVMFFINone; + result_10.zero_padding = 0; + result_10.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_10) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[0]) != 15) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)15; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_11; + result_11.type_index = kTVMFFINone; + result_11.zero_padding = 0; + result_11.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_11) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[2]) != 24) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)24; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[2])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_12; + result_12.type_index = kTVMFFINone; + result_12.zero_padding = 0; + result_12.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_12) != 0) { + return -1; + } + } + int32_t condval; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval = 1; + } else { + condval = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[2]); + } + if (condval != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_1; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval_1 = 1; + } else { + condval_1 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[2]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_1); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_13; + result_13.type_index = kTVMFFINone; + result_13.zero_padding = 0; + result_13.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_13) != 0) { + return -1; + } + } + int32_t condval_2; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval_2 = 1; + } else { + condval_2 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[1]); + } + if ((condval_2 != 24) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_14; + result_14.type_index = kTVMFFINone; + result_14.zero_padding = 0; + result_14.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_14) != 0) { + return -1; + } + } + int32_t condval_3; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval_3 = 1; + } else { + condval_3 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[0]); + } + if (((num_tokens * 24) != condval_3) && (num_tokens != 0)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_15; + result_15.type_index = kTVMFFINone; + result_15.zero_padding = 0; + result_15.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_15) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)gemm_out_mul)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_16; + result_16.type_index = kTVMFFINone; + result_16.zero_padding = 0; + result_16.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_16) != 0) { + return -1; + } + } + if ((((DLTensor*)gemm_out_mul)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_17; + result_17.type_index = kTVMFFINone; + result_17.zero_padding = 0; + result_17.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_17) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (gemm_out_mul_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_18; + result_18.type_index = kTVMFFINone; + result_18.zero_padding = 0; + result_18.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_18) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)gemm_out_sqrsum)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)gemm_out_sqrsum)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)gemm_out_sqrsum)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_19; + result_19.type_index = kTVMFFINone; + result_19.zero_padding = 0; + result_19.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_19) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[0]) != 15) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)15; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_20; + result_20.type_index = kTVMFFINone; + result_20.zero_padding = 0; + result_20.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_20) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[1])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_21; + result_21.type_index = kTVMFFINone; + result_21.zero_padding = 0; + result_21.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_21) != 0) { + return -1; + } + } + int32_t condval_4; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides == NULL)) { + condval_4 = 1; + } else { + condval_4 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides)[1]); + } + if ((condval_4 != 1) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_22; + result_22.type_index = kTVMFFINone; + result_22.zero_padding = 0; + result_22.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_22) != 0) { + return -1; + } + } + int32_t condval_5; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides == NULL)) { + condval_5 = 1; + } else { + condval_5 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides)[0]); + } + if ((((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != condval_5) && (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != 0)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_23; + result_23.type_index = kTVMFFINone; + result_23.zero_padding = 0; + result_23.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_23) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)gemm_out_sqrsum)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_24; + result_24.type_index = kTVMFFINone; + result_24.zero_padding = 0; + result_24.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_24) != 0) { + return -1; + } + } + if ((((DLTensor*)gemm_out_sqrsum)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_25; + result_25.type_index = kTVMFFINone; + result_25.zero_padding = 0; + result_25.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_25) != 0) { + return -1; + } + } + if ((((DLTensor*)gemm_out_sqrsum)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_26; + result_26.type_index = kTVMFFINone; + result_26.zero_padding = 0; + result_26.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_26) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (gemm_out_sqrsum_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_27; + result_27.type_index = kTVMFFINone; + result_27.zero_padding = 0; + result_27.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_27) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)hc_scale)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)hc_scale)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)hc_scale)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_28; + result_28.type_index = kTVMFFINone; + result_28.zero_padding = 0; + result_28.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_28) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_shape)[0]) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_29; + result_29.type_index = kTVMFFINone; + result_29.zero_padding = 0; + result_29.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_29) != 0) { + return -1; + } + } + int32_t condval_6; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides == NULL)) { + condval_6 = 1; + } else { + condval_6 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides)[0]); + } + if (condval_6 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_7; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides == NULL)) { + condval_7 = 1; + } else { + condval_7 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides)[0]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_7); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_30; + result_30.type_index = kTVMFFINone; + result_30.zero_padding = 0; + result_30.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_30) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)hc_scale)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_31; + result_31.type_index = kTVMFFINone; + result_31.zero_padding = 0; + result_31.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_31) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_scale)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_32; + result_32.type_index = kTVMFFINone; + result_32.zero_padding = 0; + result_32.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_32) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_scale)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_33; + result_33.type_index = kTVMFFINone; + result_33.zero_padding = 0; + result_33.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_33) != 0) { + return -1; + } + } + if (hc_scale_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_34; + result_34.type_index = kTVMFFINone; + result_34.zero_padding = 0; + result_34.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_34) != 0) { + return -1; + } + } + if ((((((DLTensor*)hc_base)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)hc_base)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)hc_base)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_35; + result_35.type_index = kTVMFFINone; + result_35.zero_padding = 0; + result_35.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_35) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_shape)[0]) != 24) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)24; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_36; + result_36.type_index = kTVMFFINone; + result_36.zero_padding = 0; + result_36.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_36) != 0) { + return -1; + } + } + int32_t condval_8; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides == NULL)) { + condval_8 = 1; + } else { + condval_8 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides)[0]); + } + if (condval_8 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_9; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides == NULL)) { + condval_9 = 1; + } else { + condval_9 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides)[0]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_9); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_37; + result_37.type_index = kTVMFFINone; + result_37.zero_padding = 0; + result_37.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_37) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)hc_base)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_38; + result_38.type_index = kTVMFFINone; + result_38.zero_padding = 0; + result_38.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_38) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_base)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_39; + result_39.type_index = kTVMFFINone; + result_39.zero_padding = 0; + result_39.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_39) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_base)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_40; + result_40.type_index = kTVMFFINone; + result_40.zero_padding = 0; + result_40.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_40) != 0) { + return -1; + } + } + if (hc_base_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_41; + result_41.type_index = kTVMFFINone; + result_41.zero_padding = 0; + result_41.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_41) != 0) { + return -1; + } + } + if ((((((DLTensor*)residual)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)residual)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)residual)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)residual)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)residual)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_42; + result_42.type_index = kTVMFFINone; + result_42.zero_padding = 0; + result_42.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_42) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_43; + result_43.type_index = kTVMFFINone; + result_43.zero_padding = 0; + result_43.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_43) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[1]) != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_44; + result_44.type_index = kTVMFFINone; + result_44.zero_padding = 0; + result_44.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_44) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[2]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[2])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_45; + result_45.type_index = kTVMFFINone; + result_45.zero_padding = 0; + result_45.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_45) != 0) { + return -1; + } + } + int32_t condval_10; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_10 = 1; + } else { + condval_10 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[2]); + } + if (condval_10 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_11; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_11 = 1; + } else { + condval_11 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[2]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_11); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_46; + result_46.type_index = kTVMFFINone; + result_46.zero_padding = 0; + result_46.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_46) != 0) { + return -1; + } + } + int32_t condval_12; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_12 = 1; + } else { + condval_12 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[1]); + } + if (condval_12 != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_13; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_13 = 1; + } else { + condval_13 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_13); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_47; + result_47.type_index = kTVMFFINone; + result_47.zero_padding = 0; + result_47.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_47) != 0) { + return -1; + } + } + int32_t condval_14; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_14 = 1; + } else { + condval_14 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[0]); + } + if ((condval_14 != 16384) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_48; + result_48.type_index = kTVMFFINone; + result_48.zero_padding = 0; + result_48.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_48) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)residual)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_49; + result_49.type_index = kTVMFFINone; + result_49.zero_padding = 0; + result_49.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_49) != 0) { + return -1; + } + } + if ((((DLTensor*)residual)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)residual)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_50; + result_50.type_index = kTVMFFINone; + result_50.zero_padding = 0; + result_50.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_50) != 0) { + return -1; + } + } + if ((((DLTensor*)residual)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_51; + result_51.type_index = kTVMFFINone; + result_51.zero_padding = 0; + result_51.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_51) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (residual_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_52; + result_52.type_index = kTVMFFINone; + result_52.zero_padding = 0; + result_52.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_52) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)post_mix)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)post_mix)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)post_mix)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_53; + result_53.type_index = kTVMFFINone; + result_53.zero_padding = 0; + result_53.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_53) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_54; + result_54.type_index = kTVMFFINone; + result_54.zero_padding = 0; + result_54.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_54) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[1]) != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_55; + result_55.type_index = kTVMFFINone; + result_55.zero_padding = 0; + result_55.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_55) != 0) { + return -1; + } + } + int32_t condval_15; + if ((mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides == NULL)) { + condval_15 = 1; + } else { + condval_15 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides)[1]); + } + if (condval_15 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_16; + if ((mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides == NULL)) { + condval_16 = 1; + } else { + condval_16 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_16); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_56; + result_56.type_index = kTVMFFINone; + result_56.zero_padding = 0; + result_56.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_56) != 0) { + return -1; + } + } + int32_t condval_17; + if ((mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides == NULL)) { + condval_17 = 1; + } else { + condval_17 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides)[0]); + } + if ((condval_17 != 4) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_57; + result_57.type_index = kTVMFFINone; + result_57.zero_padding = 0; + result_57.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_57) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)post_mix)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_58; + result_58.type_index = kTVMFFINone; + result_58.zero_padding = 0; + result_58.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_58) != 0) { + return -1; + } + } + if ((((DLTensor*)post_mix)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_59; + result_59.type_index = kTVMFFINone; + result_59.zero_padding = 0; + result_59.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_59) != 0) { + return -1; + } + } + if ((((DLTensor*)post_mix)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_60; + result_60.type_index = kTVMFFINone; + result_60.zero_padding = 0; + result_60.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_60) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (post_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_61; + result_61.type_index = kTVMFFINone; + result_61.zero_padding = 0; + result_61.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_61) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)comb_mix)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)comb_mix)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)comb_mix)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_62; + result_62.type_index = kTVMFFINone; + result_62.zero_padding = 0; + result_62.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_62) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_63; + result_63.type_index = kTVMFFINone; + result_63.zero_padding = 0; + result_63.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_63) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[1]) != 16) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_64; + result_64.type_index = kTVMFFINone; + result_64.zero_padding = 0; + result_64.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_64) != 0) { + return -1; + } + } + int32_t condval_18; + if ((mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides == NULL)) { + condval_18 = 1; + } else { + condval_18 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides)[1]); + } + if (condval_18 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_19; + if ((mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides == NULL)) { + condval_19 = 1; + } else { + condval_19 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_19); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_65; + result_65.type_index = kTVMFFINone; + result_65.zero_padding = 0; + result_65.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_65) != 0) { + return -1; + } + } + int32_t condval_20; + if ((mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides == NULL)) { + condval_20 = 1; + } else { + condval_20 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides)[0]); + } + if ((condval_20 != 16) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_66; + result_66.type_index = kTVMFFINone; + result_66.zero_padding = 0; + result_66.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_66) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)comb_mix)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_67; + result_67.type_index = kTVMFFINone; + result_67.zero_padding = 0; + result_67.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_67) != 0) { + return -1; + } + } + if ((((DLTensor*)comb_mix)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_68; + result_68.type_index = kTVMFFINone; + result_68.zero_padding = 0; + result_68.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_68) != 0) { + return -1; + } + } + if ((((DLTensor*)comb_mix)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_69; + result_69.type_index = kTVMFFINone; + result_69.zero_padding = 0; + result_69.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_69) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (comb_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_70; + result_70.type_index = kTVMFFINone; + result_70.zero_padding = 0; + result_70.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_70) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)layer_input)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)layer_input)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)layer_input)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_71; + result_71.type_index = kTVMFFINone; + result_71.zero_padding = 0; + result_71.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_71) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_72; + result_72.type_index = kTVMFFINone; + result_72.zero_padding = 0; + result_72.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_72) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[1]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_73; + result_73.type_index = kTVMFFINone; + result_73.zero_padding = 0; + result_73.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_73) != 0) { + return -1; + } + } + int32_t condval_21; + if ((mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides == NULL)) { + condval_21 = 1; + } else { + condval_21 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides)[1]); + } + if (condval_21 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_22; + if ((mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides == NULL)) { + condval_22 = 1; + } else { + condval_22 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_22); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_74; + result_74.type_index = kTVMFFINone; + result_74.zero_padding = 0; + result_74.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_74) != 0) { + return -1; + } + } + int32_t condval_23; + if ((mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides == NULL)) { + condval_23 = 1; + } else { + condval_23 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides)[0]); + } + if ((condval_23 != 4096) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_75; + result_75.type_index = kTVMFFINone; + result_75.zero_padding = 0; + result_75.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_75) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)layer_input)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_76; + result_76.type_index = kTVMFFINone; + result_76.zero_padding = 0; + result_76.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_76) != 0) { + return -1; + } + } + if ((((DLTensor*)layer_input)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_77; + result_77.type_index = kTVMFFINone; + result_77.zero_padding = 0; + result_77.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_77) != 0) { + return -1; + } + } + if ((((DLTensor*)layer_input)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_78; + result_78.type_index = kTVMFFINone; + result_78.zero_padding = 0; + result_78.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_78) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (layer_input_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_79; + result_79.type_index = kTVMFFINone; + result_79.zero_padding = 0; + result_79.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_79) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)norm_weight)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)norm_weight)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)norm_weight)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_80; + result_80.type_index = kTVMFFINone; + result_80.zero_padding = 0; + result_80.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_80) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_shape)[0]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_81; + result_81.type_index = kTVMFFINone; + result_81.zero_padding = 0; + result_81.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_81) != 0) { + return -1; + } + } + int32_t condval_24; + if ((mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides == NULL)) { + condval_24 = 1; + } else { + condval_24 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides)[0]); + } + if (condval_24 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_25; + if ((mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides == NULL)) { + condval_25 = 1; + } else { + condval_25 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides)[0]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_25); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_82; + result_82.type_index = kTVMFFINone; + result_82.zero_padding = 0; + result_82.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_82) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)norm_weight)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_83; + result_83.type_index = kTVMFFINone; + result_83.zero_padding = 0; + result_83.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_83) != 0) { + return -1; + } + } + if ((((DLTensor*)norm_weight)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_84; + result_84.type_index = kTVMFFINone; + result_84.zero_padding = 0; + result_84.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_84) != 0) { + return -1; + } + } + if ((((DLTensor*)norm_weight)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_85; + result_85.type_index = kTVMFFINone; + result_85.zero_padding = 0; + result_85.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_85) != 0) { + return -1; + } + } + if (norm_weight_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_86; + result_86.type_index = kTVMFFINone; + result_86.zero_padding = 0; + result_86.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_86) != 0) { + return -1; + } + } + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = ((int64_t)2); + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = ((int64_t)dev_id); + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + if (__tvm_set_device_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_set_device", &__tvm_set_device_packed) != 0) { + return -1; + } + } + TVMFFIAny result_87; + result_87.type_index = kTVMFFINone; + result_87.zero_padding = 0; + result_87.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_set_device_packed, (TVMFFIAny*) stack_ffi_any, 2, &result_87) != 0) { + return -1; + } + if (comb_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = comb_mix_1; + if (gemm_out_mul_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = gemm_out_mul_1; + if (gemm_out_sqrsum_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = gemm_out_sqrsum_1; + if (hc_base_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_ptr) = hc_base_1; + if (hc_scale_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_ptr) = hc_scale_1; + if (layer_input_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_ptr) = layer_input_1; + if (norm_weight_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_ptr) = norm_weight_1; + if (post_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_ptr) = post_mix_1; + if (residual_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_ptr) = residual_1; + (((TVMFFIAny*)stack_ffi_any)[9].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[9].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[9].v_int64) = ((int64_t)num_tokens); + (((TVMFFIAny*)stack_ffi_any)[10].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[10].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[10].v_int64) = ((int64_t)num_tokens); + (((TVMFFIAny*)stack_ffi_any)[11].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[11].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[11].v_int64) = ((int64_t)96); + (((TVMFFIAny*)stack_ffi_any)[12].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[12].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[12].v_int64) = ((int64_t)1); + (((TVMFFIAny*)stack_ffi_any)[13].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[13].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[13].v_int64) = ((int64_t)1); + (((TVMFFIAny*)stack_ffi_any)[14].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[14].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[14].v_int64) = ((int64_t)29040); + (((TVMFFIAny*)stack_ffi_any)[15].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[15].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[15].v_int64) = (int64_t)0; + if (mhc_pre_big_fuse_with_norm_tilelang_kernel_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "mhc_pre_big_fuse_with_norm_tilelang_kernel", &mhc_pre_big_fuse_with_norm_tilelang_kernel_packed) != 0) { + return -1; + } + } + TVMFFIAny result_88; + result_88.type_index = kTVMFFINone; + result_88.zero_padding = 0; + result_88.v_int64 = 0; + if (TVMFFIFunctionCall(mhc_pre_big_fuse_with_norm_tilelang_kernel_packed, (TVMFFIAny*) stack_ffi_any, 15, &result_88) != 0) { + return -1; + } + return 0; +} + +// CodegenC: NOTE: Auto-generated entry function +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_main(void* self, void* args,int num_args, void* result) { + return __tvm_ffi_mhc_pre_big_fuse_with_norm_tilelang(self, args, num_args, result); +} diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/1f58ab0397f1bec57393c246b40519995302f81a4f075621dbc500f561f77d46/params.pkl b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/1f58ab0397f1bec57393c246b40519995302f81a4f075621dbc500f561f77d46/params.pkl new file mode 100644 index 0000000..91fc240 Binary files /dev/null and b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/1f58ab0397f1bec57393c246b40519995302f81a4f075621dbc500f561f77d46/params.pkl differ diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/2271822608992f393db54113760d3441caf5e37b0ed41e8e367fb0b64d28f248/device_kernel.cu b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/2271822608992f393db54113760d3441caf5e37b0ed41e8e367fb0b64d28f248/device_kernel.cu new file mode 100644 index 0000000..cf5ce59 --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/2271822608992f393db54113760d3441caf5e37b0ed41e8e367fb0b64d28f248/device_kernel.cu @@ -0,0 +1,74 @@ +#include +#include +#include +#include +#include +#include +#ifdef ENABLE_BF16 +#include +#endif + +extern "C" __global__ void mhc_post_tilelang_kernel(const float* a, const bfloat16_t* b, const float* c, const bfloat16_t* d, bfloat16_t* x, int num_tokens); +extern "C" __global__ void __launch_bounds__(128, 1) mhc_post_tilelang_kernel(const float* a, const bfloat16_t* b, const float* c, const bfloat16_t* d, bfloat16_t* x, int num_tokens) { + extern __shared__ __align__(1024) uchar buf_dyn_shmem[]; + float a_local[16]; + float c_local[4]; + float b_local[32]; + bfloat16_t b_shared_local_cast[8]; + bfloat16_t d_shared_local_cast_1[8]; + float d_local[8]; + float x_local[32]; + bfloat16_t x_local_cast_2[8]; + cudaGridDependencySynchronize(); + #pragma unroll + for (int i = 0; i < 4; ++i) { + *(float4*)(a_local + (i * 4)) = *(float4*)(a + ((((int64_t)((int)blockIdx.x)) * (int64_t)16) + (((int64_t)i) * (int64_t)4))); + } + *(float4*)(c_local + 0) = *(float4*)(c + (((int64_t)((int)blockIdx.x)) * (int64_t)4)); + for (int i0_h = 0; i0_h < 4; ++i0_h) { + #pragma unroll + for (int i_1 = 0; i_1 < 4; ++i_1) { + *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + ((i_1 * 1024) + (((int)threadIdx.x) * 8))) = *(uint4*)(b + ((((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + (((int64_t)i_1) * (int64_t)4096)) + (((int64_t)i0_h) * (int64_t)1024)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8))); + } + *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + ((((int)threadIdx.x) * 8) + 4096)) = *(uint4*)(d + (((((int64_t)((int)blockIdx.x)) * (int64_t)4096) + (((int64_t)i0_h) * (int64_t)1024)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8))); + #pragma unroll + for (int i_2 = 0; i_2 < 4; ++i_2) { + *(uint4*)(b_shared_local_cast + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + ((i_2 * 1024) + (((int)threadIdx.x) * 8))); + for (int vec = 0; vec < 2; ++vec) { + float4 __1; + uint2 v_ = *(uint2*)(b_shared_local_cast + (vec * 4)); + ((float2*)(&__1))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v_))[0]); + ((float2*)(&__1))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v_))[1]); + *(float4*)(b_local + ((i_2 * 8) + (vec * 4))) = __1; + } + } + *(uint4*)(d_shared_local_cast_1 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + ((((int)threadIdx.x) * 8) + 4096)); + for (int i_3 = 0; i_3 < 2; ++i_3) { + float4 __2; + uint2 v__1 = *(uint2*)(d_shared_local_cast_1 + (i_3 * 4)); + ((float2*)(&__2))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__1))[0]); + ((float2*)(&__2))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__1))[1]); + *(float4*)(d_local + (i_3 * 4)) = __2; + } + #pragma unroll + for (int i_4 = 0; i_4 < 32; ++i_4) { + x_local[i_4] = (c_local[(i_4 >> 3)] * d_local[(i_4 & 7)]); + for (int i_hci = 0; i_hci < 4; ++i_hci) { + x_local[i_4] = (x_local[i_4] + (a_local[((i_hci * 4) + (i_4 >> 3))] * b_local[((i_hci * 8) + (i_4 & 7))])); + } + } + #pragma unroll + for (int i_5 = 0; i_5 < 4; ++i_5) { + for (int vec_1 = 0; vec_1 < 2; ++vec_1) { + uint2 __3; + float4 v__2 = *(float4*)(x_local + ((i_5 * 8) + (vec_1 * 4))); + (reinterpret_cast<__nv_bfloat162*>(&__3))[0] = __float22bfloat162_rn(((float2*)(&v__2))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__3))[1] = __float22bfloat162_rn(((float2*)(&v__2))[1]); + *(uint2*)(x_local_cast_2 + (vec_1 * 4)) = __3; + } + *(uint4*)(x + ((((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + (((int64_t)i_5) * (int64_t)4096)) + (((int64_t)i0_h) * (int64_t)1024)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8))) = *(uint4*)(x_local_cast_2 + 0); + } + } + cudaTriggerProgrammaticLaunchCompletion(); +} + diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/2271822608992f393db54113760d3441caf5e37b0ed41e8e367fb0b64d28f248/host_kernel.cu b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/2271822608992f393db54113760d3441caf5e37b0ed41e8e367fb0b64d28f248/host_kernel.cu new file mode 100644 index 0000000..94bb238 --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/2271822608992f393db54113760d3441caf5e37b0ed41e8e367fb0b64d28f248/host_kernel.cu @@ -0,0 +1,2176 @@ +// tilelang target: c -keys=cpu +#define TVM_EXPORTS +#include "tvm/runtime/base.h" +#include "tvm/runtime/c_backend_api.h" +#include "tvm/ffi/c_api.h" +#include +#include +#include +#ifdef __OBJC__ +#include "tvm/runtime/device_api.h" +#include "tvm/ffi/function.h" +#include +#include +#include +#endif +void* __tvm_ffi__library_ctx = NULL; +static void* __tvm_error_ndim_mismatch_packed = NULL; +static void* __tvm_error_dtype_mismatch_packed = NULL; +static void* __tvm_error_expect_eq_packed = NULL; +static void* __tvm_error_constraint_violation_packed = NULL; +static void* __tvm_error_byte_offset_mismatch_packed = NULL; +static void* __tvm_error_device_type_mismatch_packed = NULL; +static void* __tvm_error_null_ptr_packed = NULL; +static void* __tvm_set_device_packed = NULL; +static void* mhc_post_tilelang_kernel_packed = NULL; +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_mhc_post_tilelang(void* self_handle, void* args, int32_t num_args, void* result); +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_mhc_post_tilelang(void* self_handle, void* args, int32_t num_args, void* result) { + __attribute__((aligned(64))) TVMFFIAny stack[12]; + void* stack_ffi_any = stack; + if (!((num_args == 5))) { + char __tvm_assert_msg_buf[512]; + snprintf(__tvm_assert_msg_buf, 512, "%s; expected: %lld, got: %lld", "mhc_post_tilelang: num_args should be 5", (long long)(num_args), (long long)(5)); + TVMFFIErrorSetRaisedFromCStr("RuntimeError", __tvm_assert_msg_buf); + return -1; + } + if (!(!(args == NULL))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_post_tilelang: args pointer is NULL"); + return -1; + } + int32_t a_type_index = (((TVMFFIAny*)args)[0].type_index); + if (!(((((a_type_index == 0) || (a_type_index == 4)) || (a_type_index == 7)) || (64 <= a_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_post_tilelang input a expected pointer or tensor handle"); + return -1; + } + int32_t b_type_index = (((TVMFFIAny*)args)[1].type_index); + if (!(((((b_type_index == 0) || (b_type_index == 4)) || (b_type_index == 7)) || (64 <= b_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_post_tilelang input b expected pointer or tensor handle"); + return -1; + } + int32_t c_type_index = (((TVMFFIAny*)args)[2].type_index); + if (!(((((c_type_index == 0) || (c_type_index == 4)) || (c_type_index == 7)) || (64 <= c_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_post_tilelang input c expected pointer or tensor handle"); + return -1; + } + int32_t d_type_index = (((TVMFFIAny*)args)[3].type_index); + if (!(((((d_type_index == 0) || (d_type_index == 4)) || (d_type_index == 7)) || (64 <= d_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_post_tilelang input d expected pointer or tensor handle"); + return -1; + } + int32_t x_type_index = (((TVMFFIAny*)args)[4].type_index); + if (!(((((x_type_index == 0) || (x_type_index == 4)) || (x_type_index == 7)) || (64 <= x_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_post_tilelang input x expected pointer or tensor handle"); + return -1; + } + void* a = ((a_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[0].v_ptr) + 24)) : (((TVMFFIAny*)args)[0].v_ptr)); + void* b = ((b_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[1].v_ptr) + 24)) : (((TVMFFIAny*)args)[1].v_ptr)); + void* c = ((c_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[2].v_ptr) + 24)) : (((TVMFFIAny*)args)[2].v_ptr)); + void* d = ((d_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[3].v_ptr) + 24)) : (((TVMFFIAny*)args)[3].v_ptr)); + void* x = ((x_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[4].v_ptr) + 24)) : (((TVMFFIAny*)args)[4].v_ptr)); + bool mhc_post_tilelang_a_is_null = (a == NULL); + if (!(!mhc_post_tilelang_a_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_post_tilelang.a is expected to have non-NULL pointer"); + return -1; + } + bool mhc_post_tilelang_b_is_null = (b == NULL); + if (!(!mhc_post_tilelang_b_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_post_tilelang.b is expected to have non-NULL pointer"); + return -1; + } + bool mhc_post_tilelang_c_is_null = (c == NULL); + if (!(!mhc_post_tilelang_c_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_post_tilelang.c is expected to have non-NULL pointer"); + return -1; + } + bool mhc_post_tilelang_d_is_null = (d == NULL); + if (!(!mhc_post_tilelang_d_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_post_tilelang.d is expected to have non-NULL pointer"); + return -1; + } + bool mhc_post_tilelang_x_is_null = (x == NULL); + if (!(!mhc_post_tilelang_x_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_post_tilelang.x is expected to have non-NULL pointer"); + return -1; + } + void* mhc_post_tilelang_a_shape = (((DLTensor*)a)[0].shape); + void* mhc_post_tilelang_b_shape = (((DLTensor*)b)[0].shape); + void* mhc_post_tilelang_c_shape = (((DLTensor*)c)[0].shape); + void* mhc_post_tilelang_d_shape = (((DLTensor*)d)[0].shape); + void* mhc_post_tilelang_x_shape = (((DLTensor*)x)[0].shape); + if ((((DLTensor*)a)[0].ndim) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_post_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"a"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)a)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_1; + result_1.type_index = kTVMFFINone; + result_1.zero_padding = 0; + result_1.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_1) != 0) { + return -1; + } + } + if (!((bool)1)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "Symbolic shape variable num_tokens requires at least one non-null buffer among: mhc_post_tilelang.a, mhc_post_tilelang.b, mhc_post_tilelang.c, mhc_post_tilelang.d, mhc_post_tilelang.x"); + return -1; + } + int32_t num_tokens = ((int32_t)((int64_t*)mhc_post_tilelang_a_shape)[0]); + void* mhc_post_tilelang_a_strides = (((DLTensor*)a)[0].strides); + int32_t dev_id = (((DLTensor*)a)[0].device.device_id); + void* a_1 = (((DLTensor*)a)[0].data); + if ((((DLTensor*)b)[0].ndim) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_post_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"b"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)b)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_2; + result_2.type_index = kTVMFFINone; + result_2.zero_padding = 0; + result_2.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_2) != 0) { + return -1; + } + } + void* mhc_post_tilelang_b_strides = (((DLTensor*)b)[0].strides); + void* b_1 = (((DLTensor*)b)[0].data); + if ((((DLTensor*)c)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_post_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"c"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)c)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_3; + result_3.type_index = kTVMFFINone; + result_3.zero_padding = 0; + result_3.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_3) != 0) { + return -1; + } + } + void* mhc_post_tilelang_c_strides = (((DLTensor*)c)[0].strides); + void* c_1 = (((DLTensor*)c)[0].data); + if ((((DLTensor*)d)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_post_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"d"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)d)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_4; + result_4.type_index = kTVMFFINone; + result_4.zero_padding = 0; + result_4.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_4) != 0) { + return -1; + } + } + void* mhc_post_tilelang_d_strides = (((DLTensor*)d)[0].strides); + void* d_1 = (((DLTensor*)d)[0].data); + if ((((DLTensor*)x)[0].ndim) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_post_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"x"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)x)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_5; + result_5.type_index = kTVMFFINone; + result_5.zero_padding = 0; + result_5.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_5) != 0) { + return -1; + } + } + void* mhc_post_tilelang_x_strides = (((DLTensor*)x)[0].strides); + void* x_1 = (((DLTensor*)x)[0].data); + if ((((((DLTensor*)a)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)a)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)a)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_post_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"a"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)a)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)a)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)a)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_6; + result_6.type_index = kTVMFFINone; + result_6.zero_padding = 0; + result_6.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_6) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_post_tilelang_a_shape)[1]) != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_post_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"a"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_post_tilelang_a_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_7; + result_7.type_index = kTVMFFINone; + result_7.zero_padding = 0; + result_7.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_7) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_post_tilelang_a_shape)[2]) != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_post_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"a"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_post_tilelang_a_shape)[2])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_8; + result_8.type_index = kTVMFFINone; + result_8.zero_padding = 0; + result_8.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_8) != 0) { + return -1; + } + } + int32_t condval; + if ((mhc_post_tilelang_a_strides == NULL)) { + condval = 1; + } else { + condval = ((int32_t)((int64_t*)mhc_post_tilelang_a_strides)[2]); + } + if (condval != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_post_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"a"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_1; + if ((mhc_post_tilelang_a_strides == NULL)) { + condval_1 = 1; + } else { + condval_1 = ((int32_t)((int64_t*)mhc_post_tilelang_a_strides)[2]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_1); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_9; + result_9.type_index = kTVMFFINone; + result_9.zero_padding = 0; + result_9.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_9) != 0) { + return -1; + } + } + int32_t condval_2; + if ((mhc_post_tilelang_a_strides == NULL)) { + condval_2 = 1; + } else { + condval_2 = ((int32_t)((int64_t*)mhc_post_tilelang_a_strides)[1]); + } + if (condval_2 != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_post_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"a"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_3; + if ((mhc_post_tilelang_a_strides == NULL)) { + condval_3 = 1; + } else { + condval_3 = ((int32_t)((int64_t*)mhc_post_tilelang_a_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_3); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_10; + result_10.type_index = kTVMFFINone; + result_10.zero_padding = 0; + result_10.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_10) != 0) { + return -1; + } + } + int32_t condval_4; + if ((mhc_post_tilelang_a_strides == NULL)) { + condval_4 = 1; + } else { + condval_4 = ((int32_t)((int64_t*)mhc_post_tilelang_a_strides)[0]); + } + if ((condval_4 != 16) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_post_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"a"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_11; + result_11.type_index = kTVMFFINone; + result_11.zero_padding = 0; + result_11.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_11) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)a)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_post_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"a"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)a)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_12; + result_12.type_index = kTVMFFINone; + result_12.zero_padding = 0; + result_12.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_12) != 0) { + return -1; + } + } + if ((((DLTensor*)a)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_post_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"a"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)a)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_13; + result_13.type_index = kTVMFFINone; + result_13.zero_padding = 0; + result_13.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_13) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (a_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_post_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"a"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_14; + result_14.type_index = kTVMFFINone; + result_14.zero_padding = 0; + result_14.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_14) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)b)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)b)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)b)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_post_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"b"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)b)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)b)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)b)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_15; + result_15.type_index = kTVMFFINone; + result_15.zero_padding = 0; + result_15.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_15) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_post_tilelang_a_shape)[0]) != ((int32_t)((int64_t*)mhc_post_tilelang_b_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_post_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"b"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_post_tilelang_b_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_post_tilelang_a_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_16; + result_16.type_index = kTVMFFINone; + result_16.zero_padding = 0; + result_16.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_16) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_post_tilelang_b_shape)[1]) != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_post_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"b"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_post_tilelang_b_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_17; + result_17.type_index = kTVMFFINone; + result_17.zero_padding = 0; + result_17.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_17) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_post_tilelang_b_shape)[2]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_post_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"b"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_post_tilelang_b_shape)[2])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_18; + result_18.type_index = kTVMFFINone; + result_18.zero_padding = 0; + result_18.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_18) != 0) { + return -1; + } + } + int32_t condval_5; + if ((mhc_post_tilelang_b_strides == NULL)) { + condval_5 = 1; + } else { + condval_5 = ((int32_t)((int64_t*)mhc_post_tilelang_b_strides)[2]); + } + if (condval_5 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_post_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"b"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_6; + if ((mhc_post_tilelang_b_strides == NULL)) { + condval_6 = 1; + } else { + condval_6 = ((int32_t)((int64_t*)mhc_post_tilelang_b_strides)[2]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_6); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_19; + result_19.type_index = kTVMFFINone; + result_19.zero_padding = 0; + result_19.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_19) != 0) { + return -1; + } + } + int32_t condval_7; + if ((mhc_post_tilelang_b_strides == NULL)) { + condval_7 = 1; + } else { + condval_7 = ((int32_t)((int64_t*)mhc_post_tilelang_b_strides)[1]); + } + if (condval_7 != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_post_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"b"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_8; + if ((mhc_post_tilelang_b_strides == NULL)) { + condval_8 = 1; + } else { + condval_8 = ((int32_t)((int64_t*)mhc_post_tilelang_b_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_8); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_20; + result_20.type_index = kTVMFFINone; + result_20.zero_padding = 0; + result_20.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_20) != 0) { + return -1; + } + } + int32_t condval_9; + if ((mhc_post_tilelang_b_strides == NULL)) { + condval_9 = 1; + } else { + condval_9 = ((int32_t)((int64_t*)mhc_post_tilelang_b_strides)[0]); + } + if ((condval_9 != 16384) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_post_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"b"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_21; + result_21.type_index = kTVMFFINone; + result_21.zero_padding = 0; + result_21.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_21) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)b)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_post_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"b"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)b)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_22; + result_22.type_index = kTVMFFINone; + result_22.zero_padding = 0; + result_22.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_22) != 0) { + return -1; + } + } + if ((((DLTensor*)b)[0].device.device_id) != (((DLTensor*)a)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_post_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"b"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)a)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)b)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_23; + result_23.type_index = kTVMFFINone; + result_23.zero_padding = 0; + result_23.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_23) != 0) { + return -1; + } + } + if ((((DLTensor*)b)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_post_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"b"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)b)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_24; + result_24.type_index = kTVMFFINone; + result_24.zero_padding = 0; + result_24.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_24) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (b_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_post_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"b"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_25; + result_25.type_index = kTVMFFINone; + result_25.zero_padding = 0; + result_25.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_25) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)c)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)c)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)c)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_post_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"c"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)c)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)c)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)c)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_26; + result_26.type_index = kTVMFFINone; + result_26.zero_padding = 0; + result_26.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_26) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_post_tilelang_a_shape)[0]) != ((int32_t)((int64_t*)mhc_post_tilelang_c_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_post_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"c"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_post_tilelang_c_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_post_tilelang_a_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_27; + result_27.type_index = kTVMFFINone; + result_27.zero_padding = 0; + result_27.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_27) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_post_tilelang_c_shape)[1]) != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_post_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"c"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_post_tilelang_c_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_28; + result_28.type_index = kTVMFFINone; + result_28.zero_padding = 0; + result_28.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_28) != 0) { + return -1; + } + } + int32_t condval_10; + if ((mhc_post_tilelang_c_strides == NULL)) { + condval_10 = 1; + } else { + condval_10 = ((int32_t)((int64_t*)mhc_post_tilelang_c_strides)[1]); + } + if (condval_10 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_post_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"c"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_11; + if ((mhc_post_tilelang_c_strides == NULL)) { + condval_11 = 1; + } else { + condval_11 = ((int32_t)((int64_t*)mhc_post_tilelang_c_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_11); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_29; + result_29.type_index = kTVMFFINone; + result_29.zero_padding = 0; + result_29.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_29) != 0) { + return -1; + } + } + int32_t condval_12; + if ((mhc_post_tilelang_c_strides == NULL)) { + condval_12 = 1; + } else { + condval_12 = ((int32_t)((int64_t*)mhc_post_tilelang_c_strides)[0]); + } + if ((condval_12 != 4) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_post_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"c"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_30; + result_30.type_index = kTVMFFINone; + result_30.zero_padding = 0; + result_30.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_30) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)c)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_post_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"c"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)c)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_31; + result_31.type_index = kTVMFFINone; + result_31.zero_padding = 0; + result_31.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_31) != 0) { + return -1; + } + } + if ((((DLTensor*)c)[0].device.device_id) != (((DLTensor*)a)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_post_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"c"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)a)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)c)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_32; + result_32.type_index = kTVMFFINone; + result_32.zero_padding = 0; + result_32.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_32) != 0) { + return -1; + } + } + if ((((DLTensor*)c)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_post_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"c"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)c)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_33; + result_33.type_index = kTVMFFINone; + result_33.zero_padding = 0; + result_33.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_33) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (c_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_post_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"c"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_34; + result_34.type_index = kTVMFFINone; + result_34.zero_padding = 0; + result_34.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_34) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)d)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)d)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)d)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_post_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"d"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)d)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)d)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)d)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_35; + result_35.type_index = kTVMFFINone; + result_35.zero_padding = 0; + result_35.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_35) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_post_tilelang_a_shape)[0]) != ((int32_t)((int64_t*)mhc_post_tilelang_d_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_post_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"d"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_post_tilelang_d_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_post_tilelang_a_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_36; + result_36.type_index = kTVMFFINone; + result_36.zero_padding = 0; + result_36.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_36) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_post_tilelang_d_shape)[1]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_post_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"d"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_post_tilelang_d_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_37; + result_37.type_index = kTVMFFINone; + result_37.zero_padding = 0; + result_37.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_37) != 0) { + return -1; + } + } + int32_t condval_13; + if ((mhc_post_tilelang_d_strides == NULL)) { + condval_13 = 1; + } else { + condval_13 = ((int32_t)((int64_t*)mhc_post_tilelang_d_strides)[1]); + } + if (condval_13 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_post_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"d"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_14; + if ((mhc_post_tilelang_d_strides == NULL)) { + condval_14 = 1; + } else { + condval_14 = ((int32_t)((int64_t*)mhc_post_tilelang_d_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_14); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_38; + result_38.type_index = kTVMFFINone; + result_38.zero_padding = 0; + result_38.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_38) != 0) { + return -1; + } + } + int32_t condval_15; + if ((mhc_post_tilelang_d_strides == NULL)) { + condval_15 = 1; + } else { + condval_15 = ((int32_t)((int64_t*)mhc_post_tilelang_d_strides)[0]); + } + if ((condval_15 != 4096) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_post_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"d"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_39; + result_39.type_index = kTVMFFINone; + result_39.zero_padding = 0; + result_39.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_39) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)d)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_post_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"d"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)d)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_40; + result_40.type_index = kTVMFFINone; + result_40.zero_padding = 0; + result_40.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_40) != 0) { + return -1; + } + } + if ((((DLTensor*)d)[0].device.device_id) != (((DLTensor*)a)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_post_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"d"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)a)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)d)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_41; + result_41.type_index = kTVMFFINone; + result_41.zero_padding = 0; + result_41.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_41) != 0) { + return -1; + } + } + if ((((DLTensor*)d)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_post_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"d"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)d)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_42; + result_42.type_index = kTVMFFINone; + result_42.zero_padding = 0; + result_42.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_42) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (d_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_post_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"d"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_43; + result_43.type_index = kTVMFFINone; + result_43.zero_padding = 0; + result_43.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_43) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)x)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)x)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)x)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_post_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"x"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)x)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)x)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)x)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_44; + result_44.type_index = kTVMFFINone; + result_44.zero_padding = 0; + result_44.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_44) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_post_tilelang_a_shape)[0]) != ((int32_t)((int64_t*)mhc_post_tilelang_x_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_post_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"x"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_post_tilelang_x_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_post_tilelang_a_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_45; + result_45.type_index = kTVMFFINone; + result_45.zero_padding = 0; + result_45.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_45) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_post_tilelang_x_shape)[1]) != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_post_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"x"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_post_tilelang_x_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_46; + result_46.type_index = kTVMFFINone; + result_46.zero_padding = 0; + result_46.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_46) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_post_tilelang_x_shape)[2]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_post_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"x"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_post_tilelang_x_shape)[2])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_47; + result_47.type_index = kTVMFFINone; + result_47.zero_padding = 0; + result_47.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_47) != 0) { + return -1; + } + } + int32_t condval_16; + if ((mhc_post_tilelang_x_strides == NULL)) { + condval_16 = 1; + } else { + condval_16 = ((int32_t)((int64_t*)mhc_post_tilelang_x_strides)[2]); + } + if (condval_16 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_post_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"x"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_17; + if ((mhc_post_tilelang_x_strides == NULL)) { + condval_17 = 1; + } else { + condval_17 = ((int32_t)((int64_t*)mhc_post_tilelang_x_strides)[2]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_17); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_48; + result_48.type_index = kTVMFFINone; + result_48.zero_padding = 0; + result_48.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_48) != 0) { + return -1; + } + } + int32_t condval_18; + if ((mhc_post_tilelang_x_strides == NULL)) { + condval_18 = 1; + } else { + condval_18 = ((int32_t)((int64_t*)mhc_post_tilelang_x_strides)[1]); + } + if (condval_18 != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_post_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"x"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_19; + if ((mhc_post_tilelang_x_strides == NULL)) { + condval_19 = 1; + } else { + condval_19 = ((int32_t)((int64_t*)mhc_post_tilelang_x_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_19); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_49; + result_49.type_index = kTVMFFINone; + result_49.zero_padding = 0; + result_49.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_49) != 0) { + return -1; + } + } + int32_t condval_20; + if ((mhc_post_tilelang_x_strides == NULL)) { + condval_20 = 1; + } else { + condval_20 = ((int32_t)((int64_t*)mhc_post_tilelang_x_strides)[0]); + } + if ((condval_20 != 16384) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_post_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"x"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_50; + result_50.type_index = kTVMFFINone; + result_50.zero_padding = 0; + result_50.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_50) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)x)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_post_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"x"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)x)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_51; + result_51.type_index = kTVMFFINone; + result_51.zero_padding = 0; + result_51.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_51) != 0) { + return -1; + } + } + if ((((DLTensor*)x)[0].device.device_id) != (((DLTensor*)a)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_post_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"x"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)a)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)x)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_52; + result_52.type_index = kTVMFFINone; + result_52.zero_padding = 0; + result_52.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_52) != 0) { + return -1; + } + } + if ((((DLTensor*)x)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_post_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"x"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)x)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_53; + result_53.type_index = kTVMFFINone; + result_53.zero_padding = 0; + result_53.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_53) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (x_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_post_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"x"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_54; + result_54.type_index = kTVMFFINone; + result_54.zero_padding = 0; + result_54.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_54) != 0) { + return -1; + } + } + } else { + } + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = ((int64_t)2); + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = ((int64_t)dev_id); + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + if (__tvm_set_device_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_set_device", &__tvm_set_device_packed) != 0) { + return -1; + } + } + TVMFFIAny result_55; + result_55.type_index = kTVMFFINone; + result_55.zero_padding = 0; + result_55.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_set_device_packed, (TVMFFIAny*) stack_ffi_any, 2, &result_55) != 0) { + return -1; + } + if (a_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = a_1; + if (b_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = b_1; + if (c_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = c_1; + if (d_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_ptr) = d_1; + if (x_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_ptr) = x_1; + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = ((int64_t)num_tokens); + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = ((int64_t)num_tokens); + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = ((int64_t)128); + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = ((int64_t)1); + (((TVMFFIAny*)stack_ffi_any)[9].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[9].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[9].v_int64) = ((int64_t)1); + (((TVMFFIAny*)stack_ffi_any)[10].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[10].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[10].v_int64) = ((int64_t)10240); + (((TVMFFIAny*)stack_ffi_any)[11].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[11].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[11].v_int64) = (int64_t)0; + if (mhc_post_tilelang_kernel_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "mhc_post_tilelang_kernel", &mhc_post_tilelang_kernel_packed) != 0) { + return -1; + } + } + TVMFFIAny result_56; + result_56.type_index = kTVMFFINone; + result_56.zero_padding = 0; + result_56.v_int64 = 0; + if (TVMFFIFunctionCall(mhc_post_tilelang_kernel_packed, (TVMFFIAny*) stack_ffi_any, 11, &result_56) != 0) { + return -1; + } + return 0; +} + +// CodegenC: NOTE: Auto-generated entry function +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_main(void* self, void* args,int num_args, void* result) { + return __tvm_ffi_mhc_post_tilelang(self, args, num_args, result); +} diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/2271822608992f393db54113760d3441caf5e37b0ed41e8e367fb0b64d28f248/params.pkl b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/2271822608992f393db54113760d3441caf5e37b0ed41e8e367fb0b64d28f248/params.pkl new file mode 100644 index 0000000..818f970 Binary files /dev/null and b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/2271822608992f393db54113760d3441caf5e37b0ed41e8e367fb0b64d28f248/params.pkl differ diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/25b1b2d19c0004c3d858fe560874c170531adddd2ba8ea1ea0a4020fd5aeb5a3/device_kernel.cu b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/25b1b2d19c0004c3d858fe560874c170531adddd2ba8ea1ea0a4020fd5aeb5a3/device_kernel.cu new file mode 100644 index 0000000..1f8c37d --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/25b1b2d19c0004c3d858fe560874c170531adddd2ba8ea1ea0a4020fd5aeb5a3/device_kernel.cu @@ -0,0 +1,424 @@ +#include +#include +#include +#include +#include +#include +#include +#ifdef ENABLE_BF16 +#include +#endif + +extern "C" __global__ void mhc_pre_big_fuse_with_norm_tilelang_kernel(float* comb_mix, const float* gemm_out_mul, const float* gemm_out_sqrsum, const float* hc_base, const float* hc_scale, bfloat16_t* layer_input, const bfloat16_t* norm_weight, float* post_mix, const bfloat16_t* residual, int num_tokens); +extern "C" __global__ void __launch_bounds__(96, 1) mhc_pre_big_fuse_with_norm_tilelang_kernel(float* comb_mix, const float* gemm_out_mul, const float* gemm_out_sqrsum, const float* hc_base, const float* hc_scale, bfloat16_t* layer_input, const bfloat16_t* norm_weight, float* post_mix, const bfloat16_t* residual, int num_tokens) { + extern __shared__ __align__(1024) uchar buf_dyn_shmem[]; + float mixes[1]; + float rms[1]; + float cm[1]; + float row_max[1]; + float row_sum[1]; + float col_sum[1]; + float sumsq_per_pos[16]; + float sumsq[1]; + float rsqrt_norm[1]; + float xl[64]; + float ol[16]; + bfloat16_t xs_local_cast[8]; + bfloat16_t xs_local_cast_1[8]; + bfloat16_t xs_local_cast_2[8]; + float w_local[16]; + float ol_1[16]; + bfloat16_t w_shared_local_cast_3[8]; + bfloat16_t output_shared_local_cast_4[8]; + bfloat16_t layer_input_local_cast_5[8]; + bfloat16_t w_shared_local_cast_6[8]; + bfloat16_t output_shared_local_cast_7[8]; + bfloat16_t layer_input_local_cast_8[8]; + bfloat16_t w_shared_local_cast_9[8]; + bfloat16_t output_shared_local_cast_10[8]; + bfloat16_t layer_input_local_cast_11[8]; + mixes[0] = 0x0p+0f/*0.000000e+00*/; + rms[0] = 0x0p+0f/*0.000000e+00*/; + cudaGridDependencySynchronize(); + for (int i_split = 0; i_split < 26; ++i_split) { + rms[0] = (rms[0] + gemm_out_sqrsum[((((int64_t)i_split) * ((int64_t)num_tokens)) + ((int64_t)((int)blockIdx.x)))]); + } + rms[0] = rsqrtf(((rms[0] / 0x1p+14f/*1.638400e+04*/) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + mixes[0] = 0x0p+0f/*0.000000e+00*/; + for (int i_split_1 = 0; i_split_1 < 26; ++i_split_1) { + mixes[0] = (mixes[0] + gemm_out_mul[(((((int64_t)((int)blockIdx.x)) * (int64_t)24) + ((((int64_t)i_split_1) * ((int64_t)num_tokens)) * (int64_t)24)) + (((int64_t)((int)threadIdx.x)) % (int64_t)24))]); + } + mixes[0] = (mixes[0] * rms[0]); + if ((((int)threadIdx.x) / 24) == 0) { + ((float*)buf_dyn_shmem)[(((int)threadIdx.x) % 24)] = mixes[0]; + } + __syncthreads(); + if (((int)threadIdx.x) < 32) { + if (((int)threadIdx.x) < 4) { + post_mix[((((int64_t)((int)blockIdx.x)) * (int64_t)4) + ((int64_t)((int)threadIdx.x)))] = ((0x1p+0f/*1.000000e+00*/ / (0x1p+0f/*1.000000e+00*/ + expf((0x0p+0f/*0.000000e+00*/ - ((((float*)buf_dyn_shmem)[(((int)threadIdx.x) + 4)] * hc_scale[1]) + hc_base[(((int)threadIdx.x) + 4)]))))) * 0x1p+1f/*2.000000e+00*/); + } + cm[0] = ((((float*)buf_dyn_shmem)[((((int)threadIdx.x) & 15) + 8)] * hc_scale[2]) + hc_base[((((int)threadIdx.x) & 15) + 8)]); + row_max[0] = -CUDART_INF_F; + row_max[0] = max(row_max[0], cm[0]); + row_max[0] = tl::AllReduce>::run(row_max[0]); + cm[0] = expf((cm[0] - row_max[0])); + row_sum[0] = 0x0p+0f/*0.000000e+00*/; + row_sum[0] = (row_sum[0] + cm[0]); + row_sum[0] = tl::AllReduce>::run(row_sum[0]); + cm[0] = ((cm[0] / row_sum[0]) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/); + col_sum[0] = 0x0p+0f/*0.000000e+00*/; + col_sum[0] = (col_sum[0] + cm[0]); + col_sum[0] = tl::AllReduce>::run(col_sum[0]); + cm[0] = (cm[0] / (col_sum[0] + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + for (int __1 = 0; __1 < 19; ++__1) { + row_sum[0] = 0x0p+0f/*0.000000e+00*/; + row_sum[0] = (row_sum[0] + cm[0]); + row_sum[0] = tl::AllReduce>::run(row_sum[0]); + cm[0] = (cm[0] / (row_sum[0] + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + col_sum[0] = 0x0p+0f/*0.000000e+00*/; + col_sum[0] = (col_sum[0] + cm[0]); + col_sum[0] = tl::AllReduce>::run(col_sum[0]); + cm[0] = (cm[0] / (col_sum[0] + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + } + if ((((int)threadIdx.x) >> 4) == 0) { + comb_mix[((((int64_t)((int)blockIdx.x)) * (int64_t)16) + (((int64_t)((int)threadIdx.x)) & (int64_t)15))] = cm[0]; + } + } else { + if (((int)threadIdx.x) < 36) { + ((float*)buf_dyn_shmem)[(((int)threadIdx.x) + 7224)] = ((0x1p+0f/*1.000000e+00*/ / (0x1p+0f/*1.000000e+00*/ + expf((0x0p+0f/*0.000000e+00*/ - ((((float*)buf_dyn_shmem)[(((int)threadIdx.x) - 32)] * hc_scale[0]) + hc_base[(((int)threadIdx.x) - 32)]))))) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/); + } + #pragma unroll + for (int i = 0; i < 4; ++i) { + float broadcast_var = 0x0p+0f/*0.000000e+00*/; + *(float4*)(sumsq_per_pos + (i * 4)) = make_float4(broadcast_var, broadcast_var, broadcast_var, broadcast_var); + } + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_1 = 0; i_1 < 8; ++i_1) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i_1 >> 1) * 1024) + (((((i_1 * 64) + ((int)threadIdx.x)) + 96) & 127) * 8)) + 48)])), (&(residual[(((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + ((((int64_t)i_1) >> (int64_t)1) * (int64_t)4096)) + (((((((int64_t)i_1) * (int64_t)64) + ((int64_t)((int)threadIdx.x))) + (int64_t)96) & (int64_t)127) * (int64_t)8))]))); + } + tl::cp_async_commit(); + #pragma unroll + for (int i_2 = 0; i_2 < 8; ++i_2) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i_2 >> 1) * 1024) + (((((i_2 * 64) + ((int)threadIdx.x)) + 96) & 127) * 8)) + 4144)])), (&(residual[((((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + ((((int64_t)i_2) >> (int64_t)1) * (int64_t)4096)) + (((((((int64_t)i_2) * (int64_t)64) + ((int64_t)((int)threadIdx.x))) + (int64_t)96) & (int64_t)127) * (int64_t)8)) + (int64_t)1024)]))); + } + tl::cp_async_commit(); + for (int i0_h = 0; i0_h < 2; ++i0_h) { + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_3 = 0; i_3 < 8; ++i_3) { + *(uint4*)(xs_local_cast + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + ((((i0_h * 4096) + (i_3 * 512)) + (((int)threadIdx.x) * 8)) - 208)); + for (int vec = 0; vec < 2; ++vec) { + float4 __2; + uint2 v_ = *(uint2*)(xs_local_cast + (vec * 4)); + ((float2*)(&__2))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v_))[0]); + ((float2*)(&__2))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v_))[1]); + *(float4*)(xl + ((i_3 * 8) + (vec * 4))) = __2; + } + } + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_4 = 0; i_4 < 8; ++i_4) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i0_h * 4096) + ((i_4 >> 1) * 1024)) + (((((i_4 * 64) + ((int)threadIdx.x)) + 96) & 127) * 8)) + 48)])), (&(residual[(((((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + ((((int64_t)i_4) >> (int64_t)1) * (int64_t)4096)) + (((int64_t)i0_h) * (int64_t)1024)) + (((((((int64_t)i_4) * (int64_t)64) + ((int64_t)((int)threadIdx.x))) + (int64_t)96) & (int64_t)127) * (int64_t)8)) + (int64_t)2048)]))); + } + tl::cp_async_commit(); + #pragma unroll + for (int i_5 = 0; i_5 < 4; ++i_5) { + float broadcast_var_1 = 0x0p+0f/*0.000000e+00*/; + *(float4*)(ol + (i_5 * 4)) = make_float4(broadcast_var_1, broadcast_var_1, broadcast_var_1, broadcast_var_1); + } + tl::__sync_thread_partial<3, 64>(); + for (int i_hc = 0; i_hc < 4; ++i_hc) { + float pre = ((float*)buf_dyn_shmem)[(i_hc + 7256)]; + #pragma unroll + for (int i_6 = 0; i_6 < 16; ++i_6) { + ol[i_6] = (ol[i_6] + (pre * xl[((i_hc * 16) + i_6)])); + } + } + #pragma unroll + for (int i_7 = 0; i_7 < 4; ++i_7) { + float4 __3; + float4 v__1 = *(float4*)(sumsq_per_pos + (i_7 * 4)); + float4 __4; + float4 v__2 = *(float4*)(ol + (i_7 * 4)); + __4.x = (v__2.x*v__2.x); + __4.y = (v__2.y*v__2.y); + __4.z = (v__2.z*v__2.z); + __4.w = (v__2.w*v__2.w); + __3.x = (v__1.x+__4.x); + __3.y = (v__1.y+__4.y); + __3.z = (v__1.z+__4.z); + __3.w = (v__1.w+__4.w); + *(float4*)(sumsq_per_pos + (i_7 * 4)) = __3; + uint2 __5; + float4 v__3 = *(float4*)(ol + (i_7 * 4)); + (reinterpret_cast<__nv_bfloat162*>(&__5))[0] = __float22bfloat162_rn(((float2*)(&v__3))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__5))[1] = __float22bfloat162_rn(((float2*)(&v__3))[1]); + *(uint2*)(((bfloat16_t*)buf_dyn_shmem) + (((((i0_h * 1024) + ((i_7 >> 1) * 512)) + (((int)threadIdx.x) * 8)) + ((i_7 & 1) * 4)) + 7984)) = __5; + } + } + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_8 = 0; i_8 < 8; ++i_8) { + *(uint4*)(xs_local_cast_1 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_8 * 512) + (((int)threadIdx.x) * 8)) - 208)); + for (int vec_1 = 0; vec_1 < 2; ++vec_1) { + float4 __6; + uint2 v__4 = *(uint2*)(xs_local_cast_1 + (vec_1 * 4)); + ((float2*)(&__6))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__4))[0]); + ((float2*)(&__6))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__4))[1]); + *(float4*)(xl + ((i_8 * 8) + (vec_1 * 4))) = __6; + } + } + #pragma unroll + for (int i_9 = 0; i_9 < 4; ++i_9) { + float broadcast_var_2 = 0x0p+0f/*0.000000e+00*/; + *(float4*)(ol + (i_9 * 4)) = make_float4(broadcast_var_2, broadcast_var_2, broadcast_var_2, broadcast_var_2); + } + for (int i_hc_1 = 0; i_hc_1 < 4; ++i_hc_1) { + float pre_1 = ((float*)buf_dyn_shmem)[(i_hc_1 + 7256)]; + #pragma unroll + for (int i_10 = 0; i_10 < 16; ++i_10) { + ol[i_10] = (ol[i_10] + (pre_1 * xl[((i_hc_1 * 16) + i_10)])); + } + } + #pragma unroll + for (int i_11 = 0; i_11 < 4; ++i_11) { + float4 __7; + float4 v__5 = *(float4*)(sumsq_per_pos + (i_11 * 4)); + float4 __8; + float4 v__6 = *(float4*)(ol + (i_11 * 4)); + __8.x = (v__6.x*v__6.x); + __8.y = (v__6.y*v__6.y); + __8.z = (v__6.z*v__6.z); + __8.w = (v__6.w*v__6.w); + __7.x = (v__5.x+__8.x); + __7.y = (v__5.y+__8.y); + __7.z = (v__5.z+__8.z); + __7.w = (v__5.w+__8.w); + *(float4*)(sumsq_per_pos + (i_11 * 4)) = __7; + uint2 __9; + float4 v__7 = *(float4*)(ol + (i_11 * 4)); + (reinterpret_cast<__nv_bfloat162*>(&__9))[0] = __float22bfloat162_rn(((float2*)(&v__7))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__9))[1] = __float22bfloat162_rn(((float2*)(&v__7))[1]); + *(uint2*)(((bfloat16_t*)buf_dyn_shmem) + (((((i_11 >> 1) * 512) + (((int)threadIdx.x) * 8)) + ((i_11 & 1) * 4)) + 10032)) = __9; + } + tl::cp_async_wait<0>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_12 = 0; i_12 < 8; ++i_12) { + *(uint4*)(xs_local_cast_2 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_12 * 512) + (((int)threadIdx.x) * 8)) + 3888)); + for (int vec_2 = 0; vec_2 < 2; ++vec_2) { + float4 __10; + uint2 v__8 = *(uint2*)(xs_local_cast_2 + (vec_2 * 4)); + ((float2*)(&__10))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__8))[0]); + ((float2*)(&__10))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__8))[1]); + *(float4*)(xl + ((i_12 * 8) + (vec_2 * 4))) = __10; + } + } + #pragma unroll + for (int i_13 = 0; i_13 < 4; ++i_13) { + float broadcast_var_3 = 0x0p+0f/*0.000000e+00*/; + *(float4*)(ol + (i_13 * 4)) = make_float4(broadcast_var_3, broadcast_var_3, broadcast_var_3, broadcast_var_3); + } + for (int i_hc_2 = 0; i_hc_2 < 4; ++i_hc_2) { + float pre_2 = ((float*)buf_dyn_shmem)[(i_hc_2 + 7256)]; + #pragma unroll + for (int i_14 = 0; i_14 < 16; ++i_14) { + ol[i_14] = (ol[i_14] + (pre_2 * xl[((i_hc_2 * 16) + i_14)])); + } + } + #pragma unroll + for (int i_15 = 0; i_15 < 4; ++i_15) { + float4 __11; + float4 v__9 = *(float4*)(sumsq_per_pos + (i_15 * 4)); + float4 __12; + float4 v__10 = *(float4*)(ol + (i_15 * 4)); + __12.x = (v__10.x*v__10.x); + __12.y = (v__10.y*v__10.y); + __12.z = (v__10.z*v__10.z); + __12.w = (v__10.w*v__10.w); + __11.x = (v__9.x+__12.x); + __11.y = (v__9.y+__12.y); + __11.z = (v__9.z+__12.z); + __11.w = (v__9.w+__12.w); + *(float4*)(sumsq_per_pos + (i_15 * 4)) = __11; + uint2 __13; + float4 v__11 = *(float4*)(ol + (i_15 * 4)); + (reinterpret_cast<__nv_bfloat162*>(&__13))[0] = __float22bfloat162_rn(((float2*)(&v__11))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__13))[1] = __float22bfloat162_rn(((float2*)(&v__11))[1]); + *(uint2*)(((bfloat16_t*)buf_dyn_shmem) + (((((i_15 >> 1) * 512) + (((int)threadIdx.x) * 8)) + ((i_15 & 1) * 4)) + 11056)) = __13; + } + sumsq[0] = 0x0p+0f/*0.000000e+00*/; + #pragma unroll + for (int rv = 0; rv < 16; ++rv) { + sumsq[0] = (sumsq[0] + sumsq_per_pos[(((rv & 1) * 8) + (rv >> 1))]); + } + tl::__sync_thread_partial<3, 64>(); + sumsq[0] = tl::AllReduce>::run(sumsq[0], (&(((float*)buf_dyn_shmem)[7192]))); + rsqrt_norm[0] = rsqrtf(((sumsq[0] / 0x1p+12f/*4.096000e+03*/) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + #pragma unroll + for (int i_16 = 0; i_16 < 2; ++i_16) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[(((i_16 * 512) + (((int)threadIdx.x) * 8)) + 12080)])), (&(norm_weight[(((i_16 * 512) + (((int)threadIdx.x) * 8)) - 256)]))); + } + tl::cp_async_commit(); + #pragma unroll + for (int i_17 = 0; i_17 < 2; ++i_17) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[(((i_17 * 512) + (((int)threadIdx.x) * 8)) + 13104)])), (&(norm_weight[(((i_17 * 512) + (((int)threadIdx.x) * 8)) + 768)]))); + } + tl::cp_async_commit(); + for (int i0_h_1 = 0; i0_h_1 < 2; ++i0_h_1) { + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_18 = 0; i_18 < 2; ++i_18) { + *(uint4*)(w_shared_local_cast_3 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + ((((i0_h_1 * 1024) + (i_18 * 512)) + (((int)threadIdx.x) * 8)) + 12080)); + for (int vec_3 = 0; vec_3 < 2; ++vec_3) { + float4 __14; + uint2 v__12 = *(uint2*)(w_shared_local_cast_3 + (vec_3 * 4)); + ((float2*)(&__14))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__12))[0]); + ((float2*)(&__14))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__12))[1]); + *(float4*)(w_local + ((i_18 * 8) + (vec_3 * 4))) = __14; + } + } + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_19 = 0; i_19 < 2; ++i_19) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i0_h_1 * 1024) + (i_19 * 512)) + (((int)threadIdx.x) * 8)) + 12080)])), (&(norm_weight[((((i0_h_1 * 1024) + (i_19 * 512)) + (((int)threadIdx.x) * 8)) + 1792)]))); + } + tl::cp_async_commit(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_20 = 0; i_20 < 2; ++i_20) { + *(uint4*)(output_shared_local_cast_4 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + ((((i0_h_1 * 1024) + (i_20 * 512)) + (((int)threadIdx.x) * 8)) + 7984)); + for (int vec_4 = 0; vec_4 < 2; ++vec_4) { + float4 __15; + float4 __16; + float4 __17; + uint2 v__13 = *(uint2*)(output_shared_local_cast_4 + (vec_4 * 4)); + ((float2*)(&__17))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__13))[0]); + ((float2*)(&__17))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__13))[1]); + float4 v__14 = make_float4(rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0]); + __16.x = (__17.x*v__14.x); + __16.y = (__17.y*v__14.y); + __16.z = (__17.z*v__14.z); + __16.w = (__17.w*v__14.w); + float4 v__15 = *(float4*)(w_local + ((i_20 * 8) + (vec_4 * 4))); + __15.x = (__16.x*v__15.x); + __15.y = (__16.y*v__15.y); + __15.z = (__16.z*v__15.z); + __15.w = (__16.w*v__15.w); + *(float4*)(ol_1 + ((i_20 * 8) + (vec_4 * 4))) = __15; + } + } + #pragma unroll + for (int i_21 = 0; i_21 < 2; ++i_21) { + for (int vec_5 = 0; vec_5 < 2; ++vec_5) { + uint2 __18; + float4 v__16 = *(float4*)(ol_1 + ((i_21 * 8) + (vec_5 * 4))); + (reinterpret_cast<__nv_bfloat162*>(&__18))[0] = __float22bfloat162_rn(((float2*)(&v__16))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__18))[1] = __float22bfloat162_rn(((float2*)(&v__16))[1]); + *(uint2*)(layer_input_local_cast_5 + (vec_5 * 4)) = __18; + } + *(uint4*)(layer_input + (((((((int64_t)((int)blockIdx.x)) * (int64_t)4096) + (((int64_t)i0_h_1) * (int64_t)1024)) + (((int64_t)i_21) * (int64_t)512)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8)) - (int64_t)256)) = *(uint4*)(layer_input_local_cast_5 + 0); + } + } + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_22 = 0; i_22 < 2; ++i_22) { + *(uint4*)(w_shared_local_cast_6 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_22 * 512) + (((int)threadIdx.x) * 8)) + 12080)); + for (int vec_6 = 0; vec_6 < 2; ++vec_6) { + float4 __19; + uint2 v__17 = *(uint2*)(w_shared_local_cast_6 + (vec_6 * 4)); + ((float2*)(&__19))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__17))[0]); + ((float2*)(&__19))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__17))[1]); + *(float4*)(w_local + ((i_22 * 8) + (vec_6 * 4))) = __19; + } + } + #pragma unroll + for (int i_23 = 0; i_23 < 2; ++i_23) { + *(uint4*)(output_shared_local_cast_7 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_23 * 512) + (((int)threadIdx.x) * 8)) + 10032)); + for (int vec_7 = 0; vec_7 < 2; ++vec_7) { + float4 __20; + float4 __21; + float4 __22; + uint2 v__18 = *(uint2*)(output_shared_local_cast_7 + (vec_7 * 4)); + ((float2*)(&__22))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__18))[0]); + ((float2*)(&__22))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__18))[1]); + float4 v__19 = make_float4(rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0]); + __21.x = (__22.x*v__19.x); + __21.y = (__22.y*v__19.y); + __21.z = (__22.z*v__19.z); + __21.w = (__22.w*v__19.w); + float4 v__20 = *(float4*)(w_local + ((i_23 * 8) + (vec_7 * 4))); + __20.x = (__21.x*v__20.x); + __20.y = (__21.y*v__20.y); + __20.z = (__21.z*v__20.z); + __20.w = (__21.w*v__20.w); + *(float4*)(ol_1 + ((i_23 * 8) + (vec_7 * 4))) = __20; + } + } + #pragma unroll + for (int i_24 = 0; i_24 < 2; ++i_24) { + for (int vec_8 = 0; vec_8 < 2; ++vec_8) { + uint2 __23; + float4 v__21 = *(float4*)(ol_1 + ((i_24 * 8) + (vec_8 * 4))); + (reinterpret_cast<__nv_bfloat162*>(&__23))[0] = __float22bfloat162_rn(((float2*)(&v__21))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__23))[1] = __float22bfloat162_rn(((float2*)(&v__21))[1]); + *(uint2*)(layer_input_local_cast_8 + (vec_8 * 4)) = __23; + } + *(uint4*)(layer_input + ((((((int64_t)((int)blockIdx.x)) * (int64_t)4096) + (((int64_t)i_24) * (int64_t)512)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8)) + (int64_t)1792)) = *(uint4*)(layer_input_local_cast_8 + 0); + } + tl::cp_async_wait<0>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_25 = 0; i_25 < 2; ++i_25) { + *(uint4*)(w_shared_local_cast_9 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_25 * 512) + (((int)threadIdx.x) * 8)) + 13104)); + for (int vec_9 = 0; vec_9 < 2; ++vec_9) { + float4 __24; + uint2 v__22 = *(uint2*)(w_shared_local_cast_9 + (vec_9 * 4)); + ((float2*)(&__24))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__22))[0]); + ((float2*)(&__24))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__22))[1]); + *(float4*)(w_local + ((i_25 * 8) + (vec_9 * 4))) = __24; + } + } + #pragma unroll + for (int i_26 = 0; i_26 < 2; ++i_26) { + *(uint4*)(output_shared_local_cast_10 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_26 * 512) + (((int)threadIdx.x) * 8)) + 11056)); + for (int vec_10 = 0; vec_10 < 2; ++vec_10) { + float4 __25; + float4 __26; + float4 __27; + uint2 v__23 = *(uint2*)(output_shared_local_cast_10 + (vec_10 * 4)); + ((float2*)(&__27))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__23))[0]); + ((float2*)(&__27))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__23))[1]); + float4 v__24 = make_float4(rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0]); + __26.x = (__27.x*v__24.x); + __26.y = (__27.y*v__24.y); + __26.z = (__27.z*v__24.z); + __26.w = (__27.w*v__24.w); + float4 v__25 = *(float4*)(w_local + ((i_26 * 8) + (vec_10 * 4))); + __25.x = (__26.x*v__25.x); + __25.y = (__26.y*v__25.y); + __25.z = (__26.z*v__25.z); + __25.w = (__26.w*v__25.w); + *(float4*)(ol_1 + ((i_26 * 8) + (vec_10 * 4))) = __25; + } + } + #pragma unroll + for (int i_27 = 0; i_27 < 2; ++i_27) { + for (int vec_11 = 0; vec_11 < 2; ++vec_11) { + uint2 __28; + float4 v__26 = *(float4*)(ol_1 + ((i_27 * 8) + (vec_11 * 4))); + (reinterpret_cast<__nv_bfloat162*>(&__28))[0] = __float22bfloat162_rn(((float2*)(&v__26))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__28))[1] = __float22bfloat162_rn(((float2*)(&v__26))[1]); + *(uint2*)(layer_input_local_cast_11 + (vec_11 * 4)) = __28; + } + *(uint4*)(layer_input + ((((((int64_t)((int)blockIdx.x)) * (int64_t)4096) + (((int64_t)i_27) * (int64_t)512)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8)) + (int64_t)2816)) = *(uint4*)(layer_input_local_cast_11 + 0); + } + } + cudaTriggerProgrammaticLaunchCompletion(); +} + diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/25b1b2d19c0004c3d858fe560874c170531adddd2ba8ea1ea0a4020fd5aeb5a3/host_kernel.cu b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/25b1b2d19c0004c3d858fe560874c170531adddd2ba8ea1ea0a4020fd5aeb5a3/host_kernel.cu new file mode 100644 index 0000000..66cdc86 --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/25b1b2d19c0004c3d858fe560874c170531adddd2ba8ea1ea0a4020fd5aeb5a3/host_kernel.cu @@ -0,0 +1,3359 @@ +// tilelang target: c -keys=cpu +#define TVM_EXPORTS +#include "tvm/runtime/base.h" +#include "tvm/runtime/c_backend_api.h" +#include "tvm/ffi/c_api.h" +#include +#include +#include +#ifdef __OBJC__ +#include "tvm/runtime/device_api.h" +#include "tvm/ffi/function.h" +#include +#include +#include +#endif +void* __tvm_ffi__library_ctx = NULL; +static void* __tvm_error_ndim_mismatch_packed = NULL; +static void* __tvm_error_dtype_mismatch_packed = NULL; +static void* __tvm_error_expect_eq_packed = NULL; +static void* __tvm_error_constraint_violation_packed = NULL; +static void* __tvm_error_byte_offset_mismatch_packed = NULL; +static void* __tvm_error_device_type_mismatch_packed = NULL; +static void* __tvm_error_null_ptr_packed = NULL; +static void* __tvm_set_device_packed = NULL; +static void* mhc_pre_big_fuse_with_norm_tilelang_kernel_packed = NULL; +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_mhc_pre_big_fuse_with_norm_tilelang(void* self_handle, void* args, int32_t num_args, void* result); +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_mhc_pre_big_fuse_with_norm_tilelang(void* self_handle, void* args, int32_t num_args, void* result) { + __attribute__((aligned(64))) TVMFFIAny stack[16]; + void* stack_ffi_any = stack; + if (!((num_args == 9))) { + char __tvm_assert_msg_buf[512]; + snprintf(__tvm_assert_msg_buf, 512, "%s; expected: %lld, got: %lld", "mhc_pre_big_fuse_with_norm_tilelang: num_args should be 9", (long long)(num_args), (long long)(9)); + TVMFFIErrorSetRaisedFromCStr("RuntimeError", __tvm_assert_msg_buf); + return -1; + } + if (!(!(args == NULL))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang: args pointer is NULL"); + return -1; + } + int32_t gemm_out_mul_type_index = (((TVMFFIAny*)args)[0].type_index); + if (!(((((gemm_out_mul_type_index == 0) || (gemm_out_mul_type_index == 4)) || (gemm_out_mul_type_index == 7)) || (64 <= gemm_out_mul_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input gemm_out_mul expected pointer or tensor handle"); + return -1; + } + int32_t gemm_out_sqrsum_type_index = (((TVMFFIAny*)args)[1].type_index); + if (!(((((gemm_out_sqrsum_type_index == 0) || (gemm_out_sqrsum_type_index == 4)) || (gemm_out_sqrsum_type_index == 7)) || (64 <= gemm_out_sqrsum_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input gemm_out_sqrsum expected pointer or tensor handle"); + return -1; + } + int32_t hc_scale_type_index = (((TVMFFIAny*)args)[2].type_index); + if (!(((((hc_scale_type_index == 0) || (hc_scale_type_index == 4)) || (hc_scale_type_index == 7)) || (64 <= hc_scale_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input hc_scale expected pointer or tensor handle"); + return -1; + } + int32_t hc_base_type_index = (((TVMFFIAny*)args)[3].type_index); + if (!(((((hc_base_type_index == 0) || (hc_base_type_index == 4)) || (hc_base_type_index == 7)) || (64 <= hc_base_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input hc_base expected pointer or tensor handle"); + return -1; + } + int32_t residual_type_index = (((TVMFFIAny*)args)[4].type_index); + if (!(((((residual_type_index == 0) || (residual_type_index == 4)) || (residual_type_index == 7)) || (64 <= residual_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input residual expected pointer or tensor handle"); + return -1; + } + int32_t post_mix_type_index = (((TVMFFIAny*)args)[5].type_index); + if (!(((((post_mix_type_index == 0) || (post_mix_type_index == 4)) || (post_mix_type_index == 7)) || (64 <= post_mix_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input post_mix expected pointer or tensor handle"); + return -1; + } + int32_t comb_mix_type_index = (((TVMFFIAny*)args)[6].type_index); + if (!(((((comb_mix_type_index == 0) || (comb_mix_type_index == 4)) || (comb_mix_type_index == 7)) || (64 <= comb_mix_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input comb_mix expected pointer or tensor handle"); + return -1; + } + int32_t layer_input_type_index = (((TVMFFIAny*)args)[7].type_index); + if (!(((((layer_input_type_index == 0) || (layer_input_type_index == 4)) || (layer_input_type_index == 7)) || (64 <= layer_input_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input layer_input expected pointer or tensor handle"); + return -1; + } + int32_t norm_weight_type_index = (((TVMFFIAny*)args)[8].type_index); + if (!(((((norm_weight_type_index == 0) || (norm_weight_type_index == 4)) || (norm_weight_type_index == 7)) || (64 <= norm_weight_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input norm_weight expected pointer or tensor handle"); + return -1; + } + void* gemm_out_mul = ((gemm_out_mul_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[0].v_ptr) + 24)) : (((TVMFFIAny*)args)[0].v_ptr)); + void* gemm_out_sqrsum = ((gemm_out_sqrsum_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[1].v_ptr) + 24)) : (((TVMFFIAny*)args)[1].v_ptr)); + void* hc_scale = ((hc_scale_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[2].v_ptr) + 24)) : (((TVMFFIAny*)args)[2].v_ptr)); + void* hc_base = ((hc_base_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[3].v_ptr) + 24)) : (((TVMFFIAny*)args)[3].v_ptr)); + void* residual = ((residual_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[4].v_ptr) + 24)) : (((TVMFFIAny*)args)[4].v_ptr)); + void* post_mix = ((post_mix_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[5].v_ptr) + 24)) : (((TVMFFIAny*)args)[5].v_ptr)); + void* comb_mix = ((comb_mix_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[6].v_ptr) + 24)) : (((TVMFFIAny*)args)[6].v_ptr)); + void* layer_input = ((layer_input_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[7].v_ptr) + 24)) : (((TVMFFIAny*)args)[7].v_ptr)); + void* norm_weight = ((norm_weight_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[8].v_ptr) + 24)) : (((TVMFFIAny*)args)[8].v_ptr)); + bool mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_is_null = (gemm_out_mul == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.gemm_out_mul is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_is_null = (gemm_out_sqrsum == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.gemm_out_sqrsum is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_hc_scale_is_null = (hc_scale == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_hc_scale_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.hc_scale is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_hc_base_is_null = (hc_base == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_hc_base_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.hc_base is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_residual_is_null = (residual == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_residual_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.residual is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_post_mix_is_null = (post_mix == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_post_mix_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.post_mix is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_comb_mix_is_null = (comb_mix == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_comb_mix_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.comb_mix is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_layer_input_is_null = (layer_input == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_layer_input_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.layer_input is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_norm_weight_is_null = (norm_weight == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_norm_weight_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.norm_weight is expected to have non-NULL pointer"); + return -1; + } + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape = (((DLTensor*)gemm_out_mul)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape = (((DLTensor*)gemm_out_sqrsum)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_hc_scale_shape = (((DLTensor*)hc_scale)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_hc_base_shape = (((DLTensor*)hc_base)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_residual_shape = (((DLTensor*)residual)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape = (((DLTensor*)post_mix)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape = (((DLTensor*)comb_mix)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape = (((DLTensor*)layer_input)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_norm_weight_shape = (((DLTensor*)norm_weight)[0].shape); + if ((((DLTensor*)gemm_out_mul)[0].ndim) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_1; + result_1.type_index = kTVMFFINone; + result_1.zero_padding = 0; + result_1.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_1) != 0) { + return -1; + } + } + if (!((bool)1)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "Symbolic shape variable num_tokens requires at least one non-null buffer among: mhc_pre_big_fuse_with_norm_tilelang.gemm_out_mul, mhc_pre_big_fuse_with_norm_tilelang.gemm_out_sqrsum, mhc_pre_big_fuse_with_norm_tilelang.residual, mhc_pre_big_fuse_with_norm_tilelang.post_mix, mhc_pre_big_fuse_with_norm_tilelang.comb_mix, mhc_pre_big_fuse_with_norm_tilelang.layer_input"); + return -1; + } + int32_t num_tokens = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]); + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides = (((DLTensor*)gemm_out_mul)[0].strides); + int32_t dev_id = (((DLTensor*)gemm_out_mul)[0].device.device_id); + void* gemm_out_mul_1 = (((DLTensor*)gemm_out_mul)[0].data); + if ((((DLTensor*)gemm_out_sqrsum)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_2; + result_2.type_index = kTVMFFINone; + result_2.zero_padding = 0; + result_2.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_2) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides = (((DLTensor*)gemm_out_sqrsum)[0].strides); + void* gemm_out_sqrsum_1 = (((DLTensor*)gemm_out_sqrsum)[0].data); + if ((((DLTensor*)hc_scale)[0].ndim) != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_3; + result_3.type_index = kTVMFFINone; + result_3.zero_padding = 0; + result_3.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_3) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides = (((DLTensor*)hc_scale)[0].strides); + void* hc_scale_1 = (((DLTensor*)hc_scale)[0].data); + if ((((DLTensor*)hc_base)[0].ndim) != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_4; + result_4.type_index = kTVMFFINone; + result_4.zero_padding = 0; + result_4.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_4) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides = (((DLTensor*)hc_base)[0].strides); + void* hc_base_1 = (((DLTensor*)hc_base)[0].data); + if ((((DLTensor*)residual)[0].ndim) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_5; + result_5.type_index = kTVMFFINone; + result_5.zero_padding = 0; + result_5.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_5) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_residual_strides = (((DLTensor*)residual)[0].strides); + void* residual_1 = (((DLTensor*)residual)[0].data); + if ((((DLTensor*)post_mix)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_6; + result_6.type_index = kTVMFFINone; + result_6.zero_padding = 0; + result_6.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_6) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides = (((DLTensor*)post_mix)[0].strides); + void* post_mix_1 = (((DLTensor*)post_mix)[0].data); + if ((((DLTensor*)comb_mix)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_7; + result_7.type_index = kTVMFFINone; + result_7.zero_padding = 0; + result_7.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_7) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides = (((DLTensor*)comb_mix)[0].strides); + void* comb_mix_1 = (((DLTensor*)comb_mix)[0].data); + if ((((DLTensor*)layer_input)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_8; + result_8.type_index = kTVMFFINone; + result_8.zero_padding = 0; + result_8.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_8) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides = (((DLTensor*)layer_input)[0].strides); + void* layer_input_1 = (((DLTensor*)layer_input)[0].data); + if ((((DLTensor*)norm_weight)[0].ndim) != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_9; + result_9.type_index = kTVMFFINone; + result_9.zero_padding = 0; + result_9.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_9) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides = (((DLTensor*)norm_weight)[0].strides); + void* norm_weight_1 = (((DLTensor*)norm_weight)[0].data); + if ((((((DLTensor*)gemm_out_mul)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)gemm_out_mul)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)gemm_out_mul)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_10; + result_10.type_index = kTVMFFINone; + result_10.zero_padding = 0; + result_10.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_10) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[0]) != 26) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)26; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_11; + result_11.type_index = kTVMFFINone; + result_11.zero_padding = 0; + result_11.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_11) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[2]) != 24) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)24; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[2])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_12; + result_12.type_index = kTVMFFINone; + result_12.zero_padding = 0; + result_12.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_12) != 0) { + return -1; + } + } + int32_t condval; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval = 1; + } else { + condval = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[2]); + } + if (condval != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_1; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval_1 = 1; + } else { + condval_1 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[2]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_1); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_13; + result_13.type_index = kTVMFFINone; + result_13.zero_padding = 0; + result_13.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_13) != 0) { + return -1; + } + } + int32_t condval_2; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval_2 = 1; + } else { + condval_2 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[1]); + } + if ((condval_2 != 24) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_14; + result_14.type_index = kTVMFFINone; + result_14.zero_padding = 0; + result_14.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_14) != 0) { + return -1; + } + } + int32_t condval_3; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval_3 = 1; + } else { + condval_3 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[0]); + } + if (((num_tokens * 24) != condval_3) && (num_tokens != 0)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_15; + result_15.type_index = kTVMFFINone; + result_15.zero_padding = 0; + result_15.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_15) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)gemm_out_mul)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_16; + result_16.type_index = kTVMFFINone; + result_16.zero_padding = 0; + result_16.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_16) != 0) { + return -1; + } + } + if ((((DLTensor*)gemm_out_mul)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_17; + result_17.type_index = kTVMFFINone; + result_17.zero_padding = 0; + result_17.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_17) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (gemm_out_mul_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_18; + result_18.type_index = kTVMFFINone; + result_18.zero_padding = 0; + result_18.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_18) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)gemm_out_sqrsum)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)gemm_out_sqrsum)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)gemm_out_sqrsum)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_19; + result_19.type_index = kTVMFFINone; + result_19.zero_padding = 0; + result_19.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_19) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[0]) != 26) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)26; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_20; + result_20.type_index = kTVMFFINone; + result_20.zero_padding = 0; + result_20.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_20) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[1])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_21; + result_21.type_index = kTVMFFINone; + result_21.zero_padding = 0; + result_21.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_21) != 0) { + return -1; + } + } + int32_t condval_4; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides == NULL)) { + condval_4 = 1; + } else { + condval_4 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides)[1]); + } + if ((condval_4 != 1) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_22; + result_22.type_index = kTVMFFINone; + result_22.zero_padding = 0; + result_22.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_22) != 0) { + return -1; + } + } + int32_t condval_5; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides == NULL)) { + condval_5 = 1; + } else { + condval_5 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides)[0]); + } + if ((((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != condval_5) && (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != 0)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_23; + result_23.type_index = kTVMFFINone; + result_23.zero_padding = 0; + result_23.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_23) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)gemm_out_sqrsum)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_24; + result_24.type_index = kTVMFFINone; + result_24.zero_padding = 0; + result_24.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_24) != 0) { + return -1; + } + } + if ((((DLTensor*)gemm_out_sqrsum)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_25; + result_25.type_index = kTVMFFINone; + result_25.zero_padding = 0; + result_25.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_25) != 0) { + return -1; + } + } + if ((((DLTensor*)gemm_out_sqrsum)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_26; + result_26.type_index = kTVMFFINone; + result_26.zero_padding = 0; + result_26.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_26) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (gemm_out_sqrsum_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_27; + result_27.type_index = kTVMFFINone; + result_27.zero_padding = 0; + result_27.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_27) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)hc_scale)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)hc_scale)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)hc_scale)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_28; + result_28.type_index = kTVMFFINone; + result_28.zero_padding = 0; + result_28.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_28) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_shape)[0]) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_29; + result_29.type_index = kTVMFFINone; + result_29.zero_padding = 0; + result_29.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_29) != 0) { + return -1; + } + } + int32_t condval_6; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides == NULL)) { + condval_6 = 1; + } else { + condval_6 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides)[0]); + } + if (condval_6 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_7; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides == NULL)) { + condval_7 = 1; + } else { + condval_7 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides)[0]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_7); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_30; + result_30.type_index = kTVMFFINone; + result_30.zero_padding = 0; + result_30.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_30) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)hc_scale)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_31; + result_31.type_index = kTVMFFINone; + result_31.zero_padding = 0; + result_31.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_31) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_scale)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_32; + result_32.type_index = kTVMFFINone; + result_32.zero_padding = 0; + result_32.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_32) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_scale)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_33; + result_33.type_index = kTVMFFINone; + result_33.zero_padding = 0; + result_33.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_33) != 0) { + return -1; + } + } + if (hc_scale_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_34; + result_34.type_index = kTVMFFINone; + result_34.zero_padding = 0; + result_34.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_34) != 0) { + return -1; + } + } + if ((((((DLTensor*)hc_base)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)hc_base)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)hc_base)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_35; + result_35.type_index = kTVMFFINone; + result_35.zero_padding = 0; + result_35.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_35) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_shape)[0]) != 24) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)24; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_36; + result_36.type_index = kTVMFFINone; + result_36.zero_padding = 0; + result_36.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_36) != 0) { + return -1; + } + } + int32_t condval_8; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides == NULL)) { + condval_8 = 1; + } else { + condval_8 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides)[0]); + } + if (condval_8 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_9; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides == NULL)) { + condval_9 = 1; + } else { + condval_9 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides)[0]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_9); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_37; + result_37.type_index = kTVMFFINone; + result_37.zero_padding = 0; + result_37.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_37) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)hc_base)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_38; + result_38.type_index = kTVMFFINone; + result_38.zero_padding = 0; + result_38.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_38) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_base)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_39; + result_39.type_index = kTVMFFINone; + result_39.zero_padding = 0; + result_39.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_39) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_base)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_40; + result_40.type_index = kTVMFFINone; + result_40.zero_padding = 0; + result_40.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_40) != 0) { + return -1; + } + } + if (hc_base_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_41; + result_41.type_index = kTVMFFINone; + result_41.zero_padding = 0; + result_41.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_41) != 0) { + return -1; + } + } + if ((((((DLTensor*)residual)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)residual)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)residual)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)residual)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)residual)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_42; + result_42.type_index = kTVMFFINone; + result_42.zero_padding = 0; + result_42.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_42) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_43; + result_43.type_index = kTVMFFINone; + result_43.zero_padding = 0; + result_43.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_43) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[1]) != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_44; + result_44.type_index = kTVMFFINone; + result_44.zero_padding = 0; + result_44.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_44) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[2]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[2])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_45; + result_45.type_index = kTVMFFINone; + result_45.zero_padding = 0; + result_45.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_45) != 0) { + return -1; + } + } + int32_t condval_10; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_10 = 1; + } else { + condval_10 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[2]); + } + if (condval_10 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_11; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_11 = 1; + } else { + condval_11 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[2]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_11); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_46; + result_46.type_index = kTVMFFINone; + result_46.zero_padding = 0; + result_46.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_46) != 0) { + return -1; + } + } + int32_t condval_12; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_12 = 1; + } else { + condval_12 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[1]); + } + if (condval_12 != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_13; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_13 = 1; + } else { + condval_13 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_13); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_47; + result_47.type_index = kTVMFFINone; + result_47.zero_padding = 0; + result_47.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_47) != 0) { + return -1; + } + } + int32_t condval_14; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_14 = 1; + } else { + condval_14 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[0]); + } + if ((condval_14 != 16384) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_48; + result_48.type_index = kTVMFFINone; + result_48.zero_padding = 0; + result_48.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_48) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)residual)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_49; + result_49.type_index = kTVMFFINone; + result_49.zero_padding = 0; + result_49.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_49) != 0) { + return -1; + } + } + if ((((DLTensor*)residual)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)residual)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_50; + result_50.type_index = kTVMFFINone; + result_50.zero_padding = 0; + result_50.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_50) != 0) { + return -1; + } + } + if ((((DLTensor*)residual)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_51; + result_51.type_index = kTVMFFINone; + result_51.zero_padding = 0; + result_51.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_51) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (residual_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_52; + result_52.type_index = kTVMFFINone; + result_52.zero_padding = 0; + result_52.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_52) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)post_mix)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)post_mix)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)post_mix)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_53; + result_53.type_index = kTVMFFINone; + result_53.zero_padding = 0; + result_53.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_53) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_54; + result_54.type_index = kTVMFFINone; + result_54.zero_padding = 0; + result_54.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_54) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[1]) != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_55; + result_55.type_index = kTVMFFINone; + result_55.zero_padding = 0; + result_55.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_55) != 0) { + return -1; + } + } + int32_t condval_15; + if ((mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides == NULL)) { + condval_15 = 1; + } else { + condval_15 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides)[1]); + } + if (condval_15 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_16; + if ((mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides == NULL)) { + condval_16 = 1; + } else { + condval_16 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_16); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_56; + result_56.type_index = kTVMFFINone; + result_56.zero_padding = 0; + result_56.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_56) != 0) { + return -1; + } + } + int32_t condval_17; + if ((mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides == NULL)) { + condval_17 = 1; + } else { + condval_17 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides)[0]); + } + if ((condval_17 != 4) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_57; + result_57.type_index = kTVMFFINone; + result_57.zero_padding = 0; + result_57.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_57) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)post_mix)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_58; + result_58.type_index = kTVMFFINone; + result_58.zero_padding = 0; + result_58.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_58) != 0) { + return -1; + } + } + if ((((DLTensor*)post_mix)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_59; + result_59.type_index = kTVMFFINone; + result_59.zero_padding = 0; + result_59.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_59) != 0) { + return -1; + } + } + if ((((DLTensor*)post_mix)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_60; + result_60.type_index = kTVMFFINone; + result_60.zero_padding = 0; + result_60.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_60) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (post_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_61; + result_61.type_index = kTVMFFINone; + result_61.zero_padding = 0; + result_61.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_61) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)comb_mix)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)comb_mix)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)comb_mix)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_62; + result_62.type_index = kTVMFFINone; + result_62.zero_padding = 0; + result_62.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_62) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_63; + result_63.type_index = kTVMFFINone; + result_63.zero_padding = 0; + result_63.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_63) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[1]) != 16) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_64; + result_64.type_index = kTVMFFINone; + result_64.zero_padding = 0; + result_64.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_64) != 0) { + return -1; + } + } + int32_t condval_18; + if ((mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides == NULL)) { + condval_18 = 1; + } else { + condval_18 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides)[1]); + } + if (condval_18 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_19; + if ((mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides == NULL)) { + condval_19 = 1; + } else { + condval_19 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_19); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_65; + result_65.type_index = kTVMFFINone; + result_65.zero_padding = 0; + result_65.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_65) != 0) { + return -1; + } + } + int32_t condval_20; + if ((mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides == NULL)) { + condval_20 = 1; + } else { + condval_20 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides)[0]); + } + if ((condval_20 != 16) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_66; + result_66.type_index = kTVMFFINone; + result_66.zero_padding = 0; + result_66.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_66) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)comb_mix)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_67; + result_67.type_index = kTVMFFINone; + result_67.zero_padding = 0; + result_67.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_67) != 0) { + return -1; + } + } + if ((((DLTensor*)comb_mix)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_68; + result_68.type_index = kTVMFFINone; + result_68.zero_padding = 0; + result_68.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_68) != 0) { + return -1; + } + } + if ((((DLTensor*)comb_mix)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_69; + result_69.type_index = kTVMFFINone; + result_69.zero_padding = 0; + result_69.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_69) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (comb_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_70; + result_70.type_index = kTVMFFINone; + result_70.zero_padding = 0; + result_70.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_70) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)layer_input)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)layer_input)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)layer_input)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_71; + result_71.type_index = kTVMFFINone; + result_71.zero_padding = 0; + result_71.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_71) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_72; + result_72.type_index = kTVMFFINone; + result_72.zero_padding = 0; + result_72.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_72) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[1]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_73; + result_73.type_index = kTVMFFINone; + result_73.zero_padding = 0; + result_73.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_73) != 0) { + return -1; + } + } + int32_t condval_21; + if ((mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides == NULL)) { + condval_21 = 1; + } else { + condval_21 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides)[1]); + } + if (condval_21 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_22; + if ((mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides == NULL)) { + condval_22 = 1; + } else { + condval_22 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_22); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_74; + result_74.type_index = kTVMFFINone; + result_74.zero_padding = 0; + result_74.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_74) != 0) { + return -1; + } + } + int32_t condval_23; + if ((mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides == NULL)) { + condval_23 = 1; + } else { + condval_23 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides)[0]); + } + if ((condval_23 != 4096) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_75; + result_75.type_index = kTVMFFINone; + result_75.zero_padding = 0; + result_75.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_75) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)layer_input)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_76; + result_76.type_index = kTVMFFINone; + result_76.zero_padding = 0; + result_76.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_76) != 0) { + return -1; + } + } + if ((((DLTensor*)layer_input)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_77; + result_77.type_index = kTVMFFINone; + result_77.zero_padding = 0; + result_77.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_77) != 0) { + return -1; + } + } + if ((((DLTensor*)layer_input)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_78; + result_78.type_index = kTVMFFINone; + result_78.zero_padding = 0; + result_78.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_78) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (layer_input_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_79; + result_79.type_index = kTVMFFINone; + result_79.zero_padding = 0; + result_79.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_79) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)norm_weight)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)norm_weight)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)norm_weight)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_80; + result_80.type_index = kTVMFFINone; + result_80.zero_padding = 0; + result_80.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_80) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_shape)[0]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_81; + result_81.type_index = kTVMFFINone; + result_81.zero_padding = 0; + result_81.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_81) != 0) { + return -1; + } + } + int32_t condval_24; + if ((mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides == NULL)) { + condval_24 = 1; + } else { + condval_24 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides)[0]); + } + if (condval_24 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_25; + if ((mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides == NULL)) { + condval_25 = 1; + } else { + condval_25 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides)[0]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_25); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_82; + result_82.type_index = kTVMFFINone; + result_82.zero_padding = 0; + result_82.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_82) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)norm_weight)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_83; + result_83.type_index = kTVMFFINone; + result_83.zero_padding = 0; + result_83.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_83) != 0) { + return -1; + } + } + if ((((DLTensor*)norm_weight)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_84; + result_84.type_index = kTVMFFINone; + result_84.zero_padding = 0; + result_84.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_84) != 0) { + return -1; + } + } + if ((((DLTensor*)norm_weight)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_85; + result_85.type_index = kTVMFFINone; + result_85.zero_padding = 0; + result_85.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_85) != 0) { + return -1; + } + } + if (norm_weight_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_86; + result_86.type_index = kTVMFFINone; + result_86.zero_padding = 0; + result_86.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_86) != 0) { + return -1; + } + } + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = ((int64_t)2); + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = ((int64_t)dev_id); + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + if (__tvm_set_device_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_set_device", &__tvm_set_device_packed) != 0) { + return -1; + } + } + TVMFFIAny result_87; + result_87.type_index = kTVMFFINone; + result_87.zero_padding = 0; + result_87.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_set_device_packed, (TVMFFIAny*) stack_ffi_any, 2, &result_87) != 0) { + return -1; + } + if (comb_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = comb_mix_1; + if (gemm_out_mul_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = gemm_out_mul_1; + if (gemm_out_sqrsum_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = gemm_out_sqrsum_1; + if (hc_base_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_ptr) = hc_base_1; + if (hc_scale_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_ptr) = hc_scale_1; + if (layer_input_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_ptr) = layer_input_1; + if (norm_weight_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_ptr) = norm_weight_1; + if (post_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_ptr) = post_mix_1; + if (residual_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_ptr) = residual_1; + (((TVMFFIAny*)stack_ffi_any)[9].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[9].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[9].v_int64) = ((int64_t)num_tokens); + (((TVMFFIAny*)stack_ffi_any)[10].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[10].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[10].v_int64) = ((int64_t)num_tokens); + (((TVMFFIAny*)stack_ffi_any)[11].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[11].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[11].v_int64) = ((int64_t)96); + (((TVMFFIAny*)stack_ffi_any)[12].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[12].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[12].v_int64) = ((int64_t)1); + (((TVMFFIAny*)stack_ffi_any)[13].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[13].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[13].v_int64) = ((int64_t)1); + (((TVMFFIAny*)stack_ffi_any)[14].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[14].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[14].v_int64) = ((int64_t)29040); + (((TVMFFIAny*)stack_ffi_any)[15].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[15].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[15].v_int64) = (int64_t)0; + if (mhc_pre_big_fuse_with_norm_tilelang_kernel_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "mhc_pre_big_fuse_with_norm_tilelang_kernel", &mhc_pre_big_fuse_with_norm_tilelang_kernel_packed) != 0) { + return -1; + } + } + TVMFFIAny result_88; + result_88.type_index = kTVMFFINone; + result_88.zero_padding = 0; + result_88.v_int64 = 0; + if (TVMFFIFunctionCall(mhc_pre_big_fuse_with_norm_tilelang_kernel_packed, (TVMFFIAny*) stack_ffi_any, 15, &result_88) != 0) { + return -1; + } + return 0; +} + +// CodegenC: NOTE: Auto-generated entry function +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_main(void* self, void* args,int num_args, void* result) { + return __tvm_ffi_mhc_pre_big_fuse_with_norm_tilelang(self, args, num_args, result); +} diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/25b1b2d19c0004c3d858fe560874c170531adddd2ba8ea1ea0a4020fd5aeb5a3/params.pkl b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/25b1b2d19c0004c3d858fe560874c170531adddd2ba8ea1ea0a4020fd5aeb5a3/params.pkl new file mode 100644 index 0000000..8d5b15c Binary files /dev/null and b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/25b1b2d19c0004c3d858fe560874c170531adddd2ba8ea1ea0a4020fd5aeb5a3/params.pkl differ diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/2f65ba228083b031f9f8b7020d4a171fc67be94c7b476fa6fbe648831cff6878/device_kernel.cu b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/2f65ba228083b031f9f8b7020d4a171fc67be94c7b476fa6fbe648831cff6878/device_kernel.cu new file mode 100644 index 0000000..9aff242 --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/2f65ba228083b031f9f8b7020d4a171fc67be94c7b476fa6fbe648831cff6878/device_kernel.cu @@ -0,0 +1,424 @@ +#include +#include +#include +#include +#include +#include +#include +#ifdef ENABLE_BF16 +#include +#endif + +extern "C" __global__ void mhc_pre_big_fuse_with_norm_tilelang_kernel(float* comb_mix, const float* gemm_out_mul, const float* gemm_out_sqrsum, const float* hc_base, const float* hc_scale, bfloat16_t* layer_input, const bfloat16_t* norm_weight, float* post_mix, const bfloat16_t* residual, int num_tokens); +extern "C" __global__ void __launch_bounds__(96, 1) mhc_pre_big_fuse_with_norm_tilelang_kernel(float* comb_mix, const float* gemm_out_mul, const float* gemm_out_sqrsum, const float* hc_base, const float* hc_scale, bfloat16_t* layer_input, const bfloat16_t* norm_weight, float* post_mix, const bfloat16_t* residual, int num_tokens) { + extern __shared__ __align__(1024) uchar buf_dyn_shmem[]; + float mixes[1]; + float rms[1]; + float cm[1]; + float row_max[1]; + float row_sum[1]; + float col_sum[1]; + float sumsq_per_pos[16]; + float sumsq[1]; + float rsqrt_norm[1]; + float xl[64]; + float ol[16]; + bfloat16_t xs_local_cast[8]; + bfloat16_t xs_local_cast_1[8]; + bfloat16_t xs_local_cast_2[8]; + float w_local[16]; + float ol_1[16]; + bfloat16_t w_shared_local_cast_3[8]; + bfloat16_t output_shared_local_cast_4[8]; + bfloat16_t layer_input_local_cast_5[8]; + bfloat16_t w_shared_local_cast_6[8]; + bfloat16_t output_shared_local_cast_7[8]; + bfloat16_t layer_input_local_cast_8[8]; + bfloat16_t w_shared_local_cast_9[8]; + bfloat16_t output_shared_local_cast_10[8]; + bfloat16_t layer_input_local_cast_11[8]; + mixes[0] = 0x0p+0f/*0.000000e+00*/; + rms[0] = 0x0p+0f/*0.000000e+00*/; + cudaGridDependencySynchronize(); + for (int i_split = 0; i_split < 13; ++i_split) { + rms[0] = (rms[0] + gemm_out_sqrsum[((((int64_t)i_split) * ((int64_t)num_tokens)) + ((int64_t)((int)blockIdx.x)))]); + } + rms[0] = rsqrtf(((rms[0] / 0x1p+14f/*1.638400e+04*/) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + mixes[0] = 0x0p+0f/*0.000000e+00*/; + for (int i_split_1 = 0; i_split_1 < 13; ++i_split_1) { + mixes[0] = (mixes[0] + gemm_out_mul[(((((int64_t)((int)blockIdx.x)) * (int64_t)24) + ((((int64_t)i_split_1) * ((int64_t)num_tokens)) * (int64_t)24)) + (((int64_t)((int)threadIdx.x)) % (int64_t)24))]); + } + mixes[0] = (mixes[0] * rms[0]); + if ((((int)threadIdx.x) / 24) == 0) { + ((float*)buf_dyn_shmem)[(((int)threadIdx.x) % 24)] = mixes[0]; + } + __syncthreads(); + if (((int)threadIdx.x) < 32) { + if (((int)threadIdx.x) < 4) { + post_mix[((((int64_t)((int)blockIdx.x)) * (int64_t)4) + ((int64_t)((int)threadIdx.x)))] = ((0x1p+0f/*1.000000e+00*/ / (0x1p+0f/*1.000000e+00*/ + expf((0x0p+0f/*0.000000e+00*/ - ((((float*)buf_dyn_shmem)[(((int)threadIdx.x) + 4)] * hc_scale[1]) + hc_base[(((int)threadIdx.x) + 4)]))))) * 0x1p+1f/*2.000000e+00*/); + } + cm[0] = ((((float*)buf_dyn_shmem)[((((int)threadIdx.x) & 15) + 8)] * hc_scale[2]) + hc_base[((((int)threadIdx.x) & 15) + 8)]); + row_max[0] = -CUDART_INF_F; + row_max[0] = max(row_max[0], cm[0]); + row_max[0] = tl::AllReduce>::run(row_max[0]); + cm[0] = expf((cm[0] - row_max[0])); + row_sum[0] = 0x0p+0f/*0.000000e+00*/; + row_sum[0] = (row_sum[0] + cm[0]); + row_sum[0] = tl::AllReduce>::run(row_sum[0]); + cm[0] = ((cm[0] / row_sum[0]) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/); + col_sum[0] = 0x0p+0f/*0.000000e+00*/; + col_sum[0] = (col_sum[0] + cm[0]); + col_sum[0] = tl::AllReduce>::run(col_sum[0]); + cm[0] = (cm[0] / (col_sum[0] + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + for (int __1 = 0; __1 < 19; ++__1) { + row_sum[0] = 0x0p+0f/*0.000000e+00*/; + row_sum[0] = (row_sum[0] + cm[0]); + row_sum[0] = tl::AllReduce>::run(row_sum[0]); + cm[0] = (cm[0] / (row_sum[0] + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + col_sum[0] = 0x0p+0f/*0.000000e+00*/; + col_sum[0] = (col_sum[0] + cm[0]); + col_sum[0] = tl::AllReduce>::run(col_sum[0]); + cm[0] = (cm[0] / (col_sum[0] + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + } + if ((((int)threadIdx.x) >> 4) == 0) { + comb_mix[((((int64_t)((int)blockIdx.x)) * (int64_t)16) + (((int64_t)((int)threadIdx.x)) & (int64_t)15))] = cm[0]; + } + } else { + if (((int)threadIdx.x) < 36) { + ((float*)buf_dyn_shmem)[(((int)threadIdx.x) + 7224)] = ((0x1p+0f/*1.000000e+00*/ / (0x1p+0f/*1.000000e+00*/ + expf((0x0p+0f/*0.000000e+00*/ - ((((float*)buf_dyn_shmem)[(((int)threadIdx.x) - 32)] * hc_scale[0]) + hc_base[(((int)threadIdx.x) - 32)]))))) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/); + } + #pragma unroll + for (int i = 0; i < 4; ++i) { + float broadcast_var = 0x0p+0f/*0.000000e+00*/; + *(float4*)(sumsq_per_pos + (i * 4)) = make_float4(broadcast_var, broadcast_var, broadcast_var, broadcast_var); + } + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_1 = 0; i_1 < 8; ++i_1) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i_1 >> 1) * 1024) + (((((i_1 * 64) + ((int)threadIdx.x)) + 96) & 127) * 8)) + 48)])), (&(residual[(((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + ((((int64_t)i_1) >> (int64_t)1) * (int64_t)4096)) + (((((((int64_t)i_1) * (int64_t)64) + ((int64_t)((int)threadIdx.x))) + (int64_t)96) & (int64_t)127) * (int64_t)8))]))); + } + tl::cp_async_commit(); + #pragma unroll + for (int i_2 = 0; i_2 < 8; ++i_2) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i_2 >> 1) * 1024) + (((((i_2 * 64) + ((int)threadIdx.x)) + 96) & 127) * 8)) + 4144)])), (&(residual[((((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + ((((int64_t)i_2) >> (int64_t)1) * (int64_t)4096)) + (((((((int64_t)i_2) * (int64_t)64) + ((int64_t)((int)threadIdx.x))) + (int64_t)96) & (int64_t)127) * (int64_t)8)) + (int64_t)1024)]))); + } + tl::cp_async_commit(); + for (int i0_h = 0; i0_h < 2; ++i0_h) { + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_3 = 0; i_3 < 8; ++i_3) { + *(uint4*)(xs_local_cast + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + ((((i0_h * 4096) + (i_3 * 512)) + (((int)threadIdx.x) * 8)) - 208)); + for (int vec = 0; vec < 2; ++vec) { + float4 __2; + uint2 v_ = *(uint2*)(xs_local_cast + (vec * 4)); + ((float2*)(&__2))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v_))[0]); + ((float2*)(&__2))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v_))[1]); + *(float4*)(xl + ((i_3 * 8) + (vec * 4))) = __2; + } + } + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_4 = 0; i_4 < 8; ++i_4) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i0_h * 4096) + ((i_4 >> 1) * 1024)) + (((((i_4 * 64) + ((int)threadIdx.x)) + 96) & 127) * 8)) + 48)])), (&(residual[(((((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + ((((int64_t)i_4) >> (int64_t)1) * (int64_t)4096)) + (((int64_t)i0_h) * (int64_t)1024)) + (((((((int64_t)i_4) * (int64_t)64) + ((int64_t)((int)threadIdx.x))) + (int64_t)96) & (int64_t)127) * (int64_t)8)) + (int64_t)2048)]))); + } + tl::cp_async_commit(); + #pragma unroll + for (int i_5 = 0; i_5 < 4; ++i_5) { + float broadcast_var_1 = 0x0p+0f/*0.000000e+00*/; + *(float4*)(ol + (i_5 * 4)) = make_float4(broadcast_var_1, broadcast_var_1, broadcast_var_1, broadcast_var_1); + } + tl::__sync_thread_partial<3, 64>(); + for (int i_hc = 0; i_hc < 4; ++i_hc) { + float pre = ((float*)buf_dyn_shmem)[(i_hc + 7256)]; + #pragma unroll + for (int i_6 = 0; i_6 < 16; ++i_6) { + ol[i_6] = (ol[i_6] + (pre * xl[((i_hc * 16) + i_6)])); + } + } + #pragma unroll + for (int i_7 = 0; i_7 < 4; ++i_7) { + float4 __3; + float4 v__1 = *(float4*)(sumsq_per_pos + (i_7 * 4)); + float4 __4; + float4 v__2 = *(float4*)(ol + (i_7 * 4)); + __4.x = (v__2.x*v__2.x); + __4.y = (v__2.y*v__2.y); + __4.z = (v__2.z*v__2.z); + __4.w = (v__2.w*v__2.w); + __3.x = (v__1.x+__4.x); + __3.y = (v__1.y+__4.y); + __3.z = (v__1.z+__4.z); + __3.w = (v__1.w+__4.w); + *(float4*)(sumsq_per_pos + (i_7 * 4)) = __3; + uint2 __5; + float4 v__3 = *(float4*)(ol + (i_7 * 4)); + (reinterpret_cast<__nv_bfloat162*>(&__5))[0] = __float22bfloat162_rn(((float2*)(&v__3))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__5))[1] = __float22bfloat162_rn(((float2*)(&v__3))[1]); + *(uint2*)(((bfloat16_t*)buf_dyn_shmem) + (((((i0_h * 1024) + ((i_7 >> 1) * 512)) + (((int)threadIdx.x) * 8)) + ((i_7 & 1) * 4)) + 7984)) = __5; + } + } + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_8 = 0; i_8 < 8; ++i_8) { + *(uint4*)(xs_local_cast_1 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_8 * 512) + (((int)threadIdx.x) * 8)) - 208)); + for (int vec_1 = 0; vec_1 < 2; ++vec_1) { + float4 __6; + uint2 v__4 = *(uint2*)(xs_local_cast_1 + (vec_1 * 4)); + ((float2*)(&__6))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__4))[0]); + ((float2*)(&__6))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__4))[1]); + *(float4*)(xl + ((i_8 * 8) + (vec_1 * 4))) = __6; + } + } + #pragma unroll + for (int i_9 = 0; i_9 < 4; ++i_9) { + float broadcast_var_2 = 0x0p+0f/*0.000000e+00*/; + *(float4*)(ol + (i_9 * 4)) = make_float4(broadcast_var_2, broadcast_var_2, broadcast_var_2, broadcast_var_2); + } + for (int i_hc_1 = 0; i_hc_1 < 4; ++i_hc_1) { + float pre_1 = ((float*)buf_dyn_shmem)[(i_hc_1 + 7256)]; + #pragma unroll + for (int i_10 = 0; i_10 < 16; ++i_10) { + ol[i_10] = (ol[i_10] + (pre_1 * xl[((i_hc_1 * 16) + i_10)])); + } + } + #pragma unroll + for (int i_11 = 0; i_11 < 4; ++i_11) { + float4 __7; + float4 v__5 = *(float4*)(sumsq_per_pos + (i_11 * 4)); + float4 __8; + float4 v__6 = *(float4*)(ol + (i_11 * 4)); + __8.x = (v__6.x*v__6.x); + __8.y = (v__6.y*v__6.y); + __8.z = (v__6.z*v__6.z); + __8.w = (v__6.w*v__6.w); + __7.x = (v__5.x+__8.x); + __7.y = (v__5.y+__8.y); + __7.z = (v__5.z+__8.z); + __7.w = (v__5.w+__8.w); + *(float4*)(sumsq_per_pos + (i_11 * 4)) = __7; + uint2 __9; + float4 v__7 = *(float4*)(ol + (i_11 * 4)); + (reinterpret_cast<__nv_bfloat162*>(&__9))[0] = __float22bfloat162_rn(((float2*)(&v__7))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__9))[1] = __float22bfloat162_rn(((float2*)(&v__7))[1]); + *(uint2*)(((bfloat16_t*)buf_dyn_shmem) + (((((i_11 >> 1) * 512) + (((int)threadIdx.x) * 8)) + ((i_11 & 1) * 4)) + 10032)) = __9; + } + tl::cp_async_wait<0>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_12 = 0; i_12 < 8; ++i_12) { + *(uint4*)(xs_local_cast_2 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_12 * 512) + (((int)threadIdx.x) * 8)) + 3888)); + for (int vec_2 = 0; vec_2 < 2; ++vec_2) { + float4 __10; + uint2 v__8 = *(uint2*)(xs_local_cast_2 + (vec_2 * 4)); + ((float2*)(&__10))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__8))[0]); + ((float2*)(&__10))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__8))[1]); + *(float4*)(xl + ((i_12 * 8) + (vec_2 * 4))) = __10; + } + } + #pragma unroll + for (int i_13 = 0; i_13 < 4; ++i_13) { + float broadcast_var_3 = 0x0p+0f/*0.000000e+00*/; + *(float4*)(ol + (i_13 * 4)) = make_float4(broadcast_var_3, broadcast_var_3, broadcast_var_3, broadcast_var_3); + } + for (int i_hc_2 = 0; i_hc_2 < 4; ++i_hc_2) { + float pre_2 = ((float*)buf_dyn_shmem)[(i_hc_2 + 7256)]; + #pragma unroll + for (int i_14 = 0; i_14 < 16; ++i_14) { + ol[i_14] = (ol[i_14] + (pre_2 * xl[((i_hc_2 * 16) + i_14)])); + } + } + #pragma unroll + for (int i_15 = 0; i_15 < 4; ++i_15) { + float4 __11; + float4 v__9 = *(float4*)(sumsq_per_pos + (i_15 * 4)); + float4 __12; + float4 v__10 = *(float4*)(ol + (i_15 * 4)); + __12.x = (v__10.x*v__10.x); + __12.y = (v__10.y*v__10.y); + __12.z = (v__10.z*v__10.z); + __12.w = (v__10.w*v__10.w); + __11.x = (v__9.x+__12.x); + __11.y = (v__9.y+__12.y); + __11.z = (v__9.z+__12.z); + __11.w = (v__9.w+__12.w); + *(float4*)(sumsq_per_pos + (i_15 * 4)) = __11; + uint2 __13; + float4 v__11 = *(float4*)(ol + (i_15 * 4)); + (reinterpret_cast<__nv_bfloat162*>(&__13))[0] = __float22bfloat162_rn(((float2*)(&v__11))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__13))[1] = __float22bfloat162_rn(((float2*)(&v__11))[1]); + *(uint2*)(((bfloat16_t*)buf_dyn_shmem) + (((((i_15 >> 1) * 512) + (((int)threadIdx.x) * 8)) + ((i_15 & 1) * 4)) + 11056)) = __13; + } + sumsq[0] = 0x0p+0f/*0.000000e+00*/; + #pragma unroll + for (int rv = 0; rv < 16; ++rv) { + sumsq[0] = (sumsq[0] + sumsq_per_pos[(((rv & 1) * 8) + (rv >> 1))]); + } + tl::__sync_thread_partial<3, 64>(); + sumsq[0] = tl::AllReduce>::run(sumsq[0], (&(((float*)buf_dyn_shmem)[7192]))); + rsqrt_norm[0] = rsqrtf(((sumsq[0] / 0x1p+12f/*4.096000e+03*/) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + #pragma unroll + for (int i_16 = 0; i_16 < 2; ++i_16) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[(((i_16 * 512) + (((int)threadIdx.x) * 8)) + 12080)])), (&(norm_weight[(((i_16 * 512) + (((int)threadIdx.x) * 8)) - 256)]))); + } + tl::cp_async_commit(); + #pragma unroll + for (int i_17 = 0; i_17 < 2; ++i_17) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[(((i_17 * 512) + (((int)threadIdx.x) * 8)) + 13104)])), (&(norm_weight[(((i_17 * 512) + (((int)threadIdx.x) * 8)) + 768)]))); + } + tl::cp_async_commit(); + for (int i0_h_1 = 0; i0_h_1 < 2; ++i0_h_1) { + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_18 = 0; i_18 < 2; ++i_18) { + *(uint4*)(w_shared_local_cast_3 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + ((((i0_h_1 * 1024) + (i_18 * 512)) + (((int)threadIdx.x) * 8)) + 12080)); + for (int vec_3 = 0; vec_3 < 2; ++vec_3) { + float4 __14; + uint2 v__12 = *(uint2*)(w_shared_local_cast_3 + (vec_3 * 4)); + ((float2*)(&__14))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__12))[0]); + ((float2*)(&__14))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__12))[1]); + *(float4*)(w_local + ((i_18 * 8) + (vec_3 * 4))) = __14; + } + } + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_19 = 0; i_19 < 2; ++i_19) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i0_h_1 * 1024) + (i_19 * 512)) + (((int)threadIdx.x) * 8)) + 12080)])), (&(norm_weight[((((i0_h_1 * 1024) + (i_19 * 512)) + (((int)threadIdx.x) * 8)) + 1792)]))); + } + tl::cp_async_commit(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_20 = 0; i_20 < 2; ++i_20) { + *(uint4*)(output_shared_local_cast_4 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + ((((i0_h_1 * 1024) + (i_20 * 512)) + (((int)threadIdx.x) * 8)) + 7984)); + for (int vec_4 = 0; vec_4 < 2; ++vec_4) { + float4 __15; + float4 __16; + float4 __17; + uint2 v__13 = *(uint2*)(output_shared_local_cast_4 + (vec_4 * 4)); + ((float2*)(&__17))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__13))[0]); + ((float2*)(&__17))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__13))[1]); + float4 v__14 = make_float4(rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0]); + __16.x = (__17.x*v__14.x); + __16.y = (__17.y*v__14.y); + __16.z = (__17.z*v__14.z); + __16.w = (__17.w*v__14.w); + float4 v__15 = *(float4*)(w_local + ((i_20 * 8) + (vec_4 * 4))); + __15.x = (__16.x*v__15.x); + __15.y = (__16.y*v__15.y); + __15.z = (__16.z*v__15.z); + __15.w = (__16.w*v__15.w); + *(float4*)(ol_1 + ((i_20 * 8) + (vec_4 * 4))) = __15; + } + } + #pragma unroll + for (int i_21 = 0; i_21 < 2; ++i_21) { + for (int vec_5 = 0; vec_5 < 2; ++vec_5) { + uint2 __18; + float4 v__16 = *(float4*)(ol_1 + ((i_21 * 8) + (vec_5 * 4))); + (reinterpret_cast<__nv_bfloat162*>(&__18))[0] = __float22bfloat162_rn(((float2*)(&v__16))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__18))[1] = __float22bfloat162_rn(((float2*)(&v__16))[1]); + *(uint2*)(layer_input_local_cast_5 + (vec_5 * 4)) = __18; + } + *(uint4*)(layer_input + (((((((int64_t)((int)blockIdx.x)) * (int64_t)4096) + (((int64_t)i0_h_1) * (int64_t)1024)) + (((int64_t)i_21) * (int64_t)512)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8)) - (int64_t)256)) = *(uint4*)(layer_input_local_cast_5 + 0); + } + } + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_22 = 0; i_22 < 2; ++i_22) { + *(uint4*)(w_shared_local_cast_6 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_22 * 512) + (((int)threadIdx.x) * 8)) + 12080)); + for (int vec_6 = 0; vec_6 < 2; ++vec_6) { + float4 __19; + uint2 v__17 = *(uint2*)(w_shared_local_cast_6 + (vec_6 * 4)); + ((float2*)(&__19))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__17))[0]); + ((float2*)(&__19))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__17))[1]); + *(float4*)(w_local + ((i_22 * 8) + (vec_6 * 4))) = __19; + } + } + #pragma unroll + for (int i_23 = 0; i_23 < 2; ++i_23) { + *(uint4*)(output_shared_local_cast_7 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_23 * 512) + (((int)threadIdx.x) * 8)) + 10032)); + for (int vec_7 = 0; vec_7 < 2; ++vec_7) { + float4 __20; + float4 __21; + float4 __22; + uint2 v__18 = *(uint2*)(output_shared_local_cast_7 + (vec_7 * 4)); + ((float2*)(&__22))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__18))[0]); + ((float2*)(&__22))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__18))[1]); + float4 v__19 = make_float4(rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0]); + __21.x = (__22.x*v__19.x); + __21.y = (__22.y*v__19.y); + __21.z = (__22.z*v__19.z); + __21.w = (__22.w*v__19.w); + float4 v__20 = *(float4*)(w_local + ((i_23 * 8) + (vec_7 * 4))); + __20.x = (__21.x*v__20.x); + __20.y = (__21.y*v__20.y); + __20.z = (__21.z*v__20.z); + __20.w = (__21.w*v__20.w); + *(float4*)(ol_1 + ((i_23 * 8) + (vec_7 * 4))) = __20; + } + } + #pragma unroll + for (int i_24 = 0; i_24 < 2; ++i_24) { + for (int vec_8 = 0; vec_8 < 2; ++vec_8) { + uint2 __23; + float4 v__21 = *(float4*)(ol_1 + ((i_24 * 8) + (vec_8 * 4))); + (reinterpret_cast<__nv_bfloat162*>(&__23))[0] = __float22bfloat162_rn(((float2*)(&v__21))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__23))[1] = __float22bfloat162_rn(((float2*)(&v__21))[1]); + *(uint2*)(layer_input_local_cast_8 + (vec_8 * 4)) = __23; + } + *(uint4*)(layer_input + ((((((int64_t)((int)blockIdx.x)) * (int64_t)4096) + (((int64_t)i_24) * (int64_t)512)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8)) + (int64_t)1792)) = *(uint4*)(layer_input_local_cast_8 + 0); + } + tl::cp_async_wait<0>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_25 = 0; i_25 < 2; ++i_25) { + *(uint4*)(w_shared_local_cast_9 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_25 * 512) + (((int)threadIdx.x) * 8)) + 13104)); + for (int vec_9 = 0; vec_9 < 2; ++vec_9) { + float4 __24; + uint2 v__22 = *(uint2*)(w_shared_local_cast_9 + (vec_9 * 4)); + ((float2*)(&__24))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__22))[0]); + ((float2*)(&__24))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__22))[1]); + *(float4*)(w_local + ((i_25 * 8) + (vec_9 * 4))) = __24; + } + } + #pragma unroll + for (int i_26 = 0; i_26 < 2; ++i_26) { + *(uint4*)(output_shared_local_cast_10 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_26 * 512) + (((int)threadIdx.x) * 8)) + 11056)); + for (int vec_10 = 0; vec_10 < 2; ++vec_10) { + float4 __25; + float4 __26; + float4 __27; + uint2 v__23 = *(uint2*)(output_shared_local_cast_10 + (vec_10 * 4)); + ((float2*)(&__27))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__23))[0]); + ((float2*)(&__27))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__23))[1]); + float4 v__24 = make_float4(rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0]); + __26.x = (__27.x*v__24.x); + __26.y = (__27.y*v__24.y); + __26.z = (__27.z*v__24.z); + __26.w = (__27.w*v__24.w); + float4 v__25 = *(float4*)(w_local + ((i_26 * 8) + (vec_10 * 4))); + __25.x = (__26.x*v__25.x); + __25.y = (__26.y*v__25.y); + __25.z = (__26.z*v__25.z); + __25.w = (__26.w*v__25.w); + *(float4*)(ol_1 + ((i_26 * 8) + (vec_10 * 4))) = __25; + } + } + #pragma unroll + for (int i_27 = 0; i_27 < 2; ++i_27) { + for (int vec_11 = 0; vec_11 < 2; ++vec_11) { + uint2 __28; + float4 v__26 = *(float4*)(ol_1 + ((i_27 * 8) + (vec_11 * 4))); + (reinterpret_cast<__nv_bfloat162*>(&__28))[0] = __float22bfloat162_rn(((float2*)(&v__26))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__28))[1] = __float22bfloat162_rn(((float2*)(&v__26))[1]); + *(uint2*)(layer_input_local_cast_11 + (vec_11 * 4)) = __28; + } + *(uint4*)(layer_input + ((((((int64_t)((int)blockIdx.x)) * (int64_t)4096) + (((int64_t)i_27) * (int64_t)512)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8)) + (int64_t)2816)) = *(uint4*)(layer_input_local_cast_11 + 0); + } + } + cudaTriggerProgrammaticLaunchCompletion(); +} + diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/2f65ba228083b031f9f8b7020d4a171fc67be94c7b476fa6fbe648831cff6878/host_kernel.cu b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/2f65ba228083b031f9f8b7020d4a171fc67be94c7b476fa6fbe648831cff6878/host_kernel.cu new file mode 100644 index 0000000..04f7c6f --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/2f65ba228083b031f9f8b7020d4a171fc67be94c7b476fa6fbe648831cff6878/host_kernel.cu @@ -0,0 +1,3359 @@ +// tilelang target: c -keys=cpu +#define TVM_EXPORTS +#include "tvm/runtime/base.h" +#include "tvm/runtime/c_backend_api.h" +#include "tvm/ffi/c_api.h" +#include +#include +#include +#ifdef __OBJC__ +#include "tvm/runtime/device_api.h" +#include "tvm/ffi/function.h" +#include +#include +#include +#endif +void* __tvm_ffi__library_ctx = NULL; +static void* __tvm_error_ndim_mismatch_packed = NULL; +static void* __tvm_error_dtype_mismatch_packed = NULL; +static void* __tvm_error_expect_eq_packed = NULL; +static void* __tvm_error_constraint_violation_packed = NULL; +static void* __tvm_error_byte_offset_mismatch_packed = NULL; +static void* __tvm_error_device_type_mismatch_packed = NULL; +static void* __tvm_error_null_ptr_packed = NULL; +static void* __tvm_set_device_packed = NULL; +static void* mhc_pre_big_fuse_with_norm_tilelang_kernel_packed = NULL; +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_mhc_pre_big_fuse_with_norm_tilelang(void* self_handle, void* args, int32_t num_args, void* result); +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_mhc_pre_big_fuse_with_norm_tilelang(void* self_handle, void* args, int32_t num_args, void* result) { + __attribute__((aligned(64))) TVMFFIAny stack[16]; + void* stack_ffi_any = stack; + if (!((num_args == 9))) { + char __tvm_assert_msg_buf[512]; + snprintf(__tvm_assert_msg_buf, 512, "%s; expected: %lld, got: %lld", "mhc_pre_big_fuse_with_norm_tilelang: num_args should be 9", (long long)(num_args), (long long)(9)); + TVMFFIErrorSetRaisedFromCStr("RuntimeError", __tvm_assert_msg_buf); + return -1; + } + if (!(!(args == NULL))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang: args pointer is NULL"); + return -1; + } + int32_t gemm_out_mul_type_index = (((TVMFFIAny*)args)[0].type_index); + if (!(((((gemm_out_mul_type_index == 0) || (gemm_out_mul_type_index == 4)) || (gemm_out_mul_type_index == 7)) || (64 <= gemm_out_mul_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input gemm_out_mul expected pointer or tensor handle"); + return -1; + } + int32_t gemm_out_sqrsum_type_index = (((TVMFFIAny*)args)[1].type_index); + if (!(((((gemm_out_sqrsum_type_index == 0) || (gemm_out_sqrsum_type_index == 4)) || (gemm_out_sqrsum_type_index == 7)) || (64 <= gemm_out_sqrsum_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input gemm_out_sqrsum expected pointer or tensor handle"); + return -1; + } + int32_t hc_scale_type_index = (((TVMFFIAny*)args)[2].type_index); + if (!(((((hc_scale_type_index == 0) || (hc_scale_type_index == 4)) || (hc_scale_type_index == 7)) || (64 <= hc_scale_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input hc_scale expected pointer or tensor handle"); + return -1; + } + int32_t hc_base_type_index = (((TVMFFIAny*)args)[3].type_index); + if (!(((((hc_base_type_index == 0) || (hc_base_type_index == 4)) || (hc_base_type_index == 7)) || (64 <= hc_base_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input hc_base expected pointer or tensor handle"); + return -1; + } + int32_t residual_type_index = (((TVMFFIAny*)args)[4].type_index); + if (!(((((residual_type_index == 0) || (residual_type_index == 4)) || (residual_type_index == 7)) || (64 <= residual_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input residual expected pointer or tensor handle"); + return -1; + } + int32_t post_mix_type_index = (((TVMFFIAny*)args)[5].type_index); + if (!(((((post_mix_type_index == 0) || (post_mix_type_index == 4)) || (post_mix_type_index == 7)) || (64 <= post_mix_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input post_mix expected pointer or tensor handle"); + return -1; + } + int32_t comb_mix_type_index = (((TVMFFIAny*)args)[6].type_index); + if (!(((((comb_mix_type_index == 0) || (comb_mix_type_index == 4)) || (comb_mix_type_index == 7)) || (64 <= comb_mix_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input comb_mix expected pointer or tensor handle"); + return -1; + } + int32_t layer_input_type_index = (((TVMFFIAny*)args)[7].type_index); + if (!(((((layer_input_type_index == 0) || (layer_input_type_index == 4)) || (layer_input_type_index == 7)) || (64 <= layer_input_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input layer_input expected pointer or tensor handle"); + return -1; + } + int32_t norm_weight_type_index = (((TVMFFIAny*)args)[8].type_index); + if (!(((((norm_weight_type_index == 0) || (norm_weight_type_index == 4)) || (norm_weight_type_index == 7)) || (64 <= norm_weight_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input norm_weight expected pointer or tensor handle"); + return -1; + } + void* gemm_out_mul = ((gemm_out_mul_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[0].v_ptr) + 24)) : (((TVMFFIAny*)args)[0].v_ptr)); + void* gemm_out_sqrsum = ((gemm_out_sqrsum_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[1].v_ptr) + 24)) : (((TVMFFIAny*)args)[1].v_ptr)); + void* hc_scale = ((hc_scale_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[2].v_ptr) + 24)) : (((TVMFFIAny*)args)[2].v_ptr)); + void* hc_base = ((hc_base_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[3].v_ptr) + 24)) : (((TVMFFIAny*)args)[3].v_ptr)); + void* residual = ((residual_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[4].v_ptr) + 24)) : (((TVMFFIAny*)args)[4].v_ptr)); + void* post_mix = ((post_mix_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[5].v_ptr) + 24)) : (((TVMFFIAny*)args)[5].v_ptr)); + void* comb_mix = ((comb_mix_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[6].v_ptr) + 24)) : (((TVMFFIAny*)args)[6].v_ptr)); + void* layer_input = ((layer_input_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[7].v_ptr) + 24)) : (((TVMFFIAny*)args)[7].v_ptr)); + void* norm_weight = ((norm_weight_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[8].v_ptr) + 24)) : (((TVMFFIAny*)args)[8].v_ptr)); + bool mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_is_null = (gemm_out_mul == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.gemm_out_mul is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_is_null = (gemm_out_sqrsum == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.gemm_out_sqrsum is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_hc_scale_is_null = (hc_scale == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_hc_scale_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.hc_scale is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_hc_base_is_null = (hc_base == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_hc_base_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.hc_base is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_residual_is_null = (residual == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_residual_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.residual is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_post_mix_is_null = (post_mix == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_post_mix_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.post_mix is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_comb_mix_is_null = (comb_mix == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_comb_mix_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.comb_mix is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_layer_input_is_null = (layer_input == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_layer_input_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.layer_input is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_norm_weight_is_null = (norm_weight == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_norm_weight_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.norm_weight is expected to have non-NULL pointer"); + return -1; + } + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape = (((DLTensor*)gemm_out_mul)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape = (((DLTensor*)gemm_out_sqrsum)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_hc_scale_shape = (((DLTensor*)hc_scale)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_hc_base_shape = (((DLTensor*)hc_base)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_residual_shape = (((DLTensor*)residual)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape = (((DLTensor*)post_mix)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape = (((DLTensor*)comb_mix)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape = (((DLTensor*)layer_input)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_norm_weight_shape = (((DLTensor*)norm_weight)[0].shape); + if ((((DLTensor*)gemm_out_mul)[0].ndim) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_1; + result_1.type_index = kTVMFFINone; + result_1.zero_padding = 0; + result_1.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_1) != 0) { + return -1; + } + } + if (!((bool)1)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "Symbolic shape variable num_tokens requires at least one non-null buffer among: mhc_pre_big_fuse_with_norm_tilelang.gemm_out_mul, mhc_pre_big_fuse_with_norm_tilelang.gemm_out_sqrsum, mhc_pre_big_fuse_with_norm_tilelang.residual, mhc_pre_big_fuse_with_norm_tilelang.post_mix, mhc_pre_big_fuse_with_norm_tilelang.comb_mix, mhc_pre_big_fuse_with_norm_tilelang.layer_input"); + return -1; + } + int32_t num_tokens = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]); + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides = (((DLTensor*)gemm_out_mul)[0].strides); + int32_t dev_id = (((DLTensor*)gemm_out_mul)[0].device.device_id); + void* gemm_out_mul_1 = (((DLTensor*)gemm_out_mul)[0].data); + if ((((DLTensor*)gemm_out_sqrsum)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_2; + result_2.type_index = kTVMFFINone; + result_2.zero_padding = 0; + result_2.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_2) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides = (((DLTensor*)gemm_out_sqrsum)[0].strides); + void* gemm_out_sqrsum_1 = (((DLTensor*)gemm_out_sqrsum)[0].data); + if ((((DLTensor*)hc_scale)[0].ndim) != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_3; + result_3.type_index = kTVMFFINone; + result_3.zero_padding = 0; + result_3.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_3) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides = (((DLTensor*)hc_scale)[0].strides); + void* hc_scale_1 = (((DLTensor*)hc_scale)[0].data); + if ((((DLTensor*)hc_base)[0].ndim) != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_4; + result_4.type_index = kTVMFFINone; + result_4.zero_padding = 0; + result_4.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_4) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides = (((DLTensor*)hc_base)[0].strides); + void* hc_base_1 = (((DLTensor*)hc_base)[0].data); + if ((((DLTensor*)residual)[0].ndim) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_5; + result_5.type_index = kTVMFFINone; + result_5.zero_padding = 0; + result_5.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_5) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_residual_strides = (((DLTensor*)residual)[0].strides); + void* residual_1 = (((DLTensor*)residual)[0].data); + if ((((DLTensor*)post_mix)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_6; + result_6.type_index = kTVMFFINone; + result_6.zero_padding = 0; + result_6.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_6) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides = (((DLTensor*)post_mix)[0].strides); + void* post_mix_1 = (((DLTensor*)post_mix)[0].data); + if ((((DLTensor*)comb_mix)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_7; + result_7.type_index = kTVMFFINone; + result_7.zero_padding = 0; + result_7.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_7) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides = (((DLTensor*)comb_mix)[0].strides); + void* comb_mix_1 = (((DLTensor*)comb_mix)[0].data); + if ((((DLTensor*)layer_input)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_8; + result_8.type_index = kTVMFFINone; + result_8.zero_padding = 0; + result_8.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_8) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides = (((DLTensor*)layer_input)[0].strides); + void* layer_input_1 = (((DLTensor*)layer_input)[0].data); + if ((((DLTensor*)norm_weight)[0].ndim) != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_9; + result_9.type_index = kTVMFFINone; + result_9.zero_padding = 0; + result_9.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_9) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides = (((DLTensor*)norm_weight)[0].strides); + void* norm_weight_1 = (((DLTensor*)norm_weight)[0].data); + if ((((((DLTensor*)gemm_out_mul)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)gemm_out_mul)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)gemm_out_mul)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_10; + result_10.type_index = kTVMFFINone; + result_10.zero_padding = 0; + result_10.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_10) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[0]) != 13) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)13; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_11; + result_11.type_index = kTVMFFINone; + result_11.zero_padding = 0; + result_11.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_11) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[2]) != 24) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)24; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[2])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_12; + result_12.type_index = kTVMFFINone; + result_12.zero_padding = 0; + result_12.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_12) != 0) { + return -1; + } + } + int32_t condval; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval = 1; + } else { + condval = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[2]); + } + if (condval != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_1; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval_1 = 1; + } else { + condval_1 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[2]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_1); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_13; + result_13.type_index = kTVMFFINone; + result_13.zero_padding = 0; + result_13.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_13) != 0) { + return -1; + } + } + int32_t condval_2; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval_2 = 1; + } else { + condval_2 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[1]); + } + if ((condval_2 != 24) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_14; + result_14.type_index = kTVMFFINone; + result_14.zero_padding = 0; + result_14.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_14) != 0) { + return -1; + } + } + int32_t condval_3; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval_3 = 1; + } else { + condval_3 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[0]); + } + if (((num_tokens * 24) != condval_3) && (num_tokens != 0)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_15; + result_15.type_index = kTVMFFINone; + result_15.zero_padding = 0; + result_15.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_15) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)gemm_out_mul)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_16; + result_16.type_index = kTVMFFINone; + result_16.zero_padding = 0; + result_16.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_16) != 0) { + return -1; + } + } + if ((((DLTensor*)gemm_out_mul)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_17; + result_17.type_index = kTVMFFINone; + result_17.zero_padding = 0; + result_17.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_17) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (gemm_out_mul_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_18; + result_18.type_index = kTVMFFINone; + result_18.zero_padding = 0; + result_18.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_18) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)gemm_out_sqrsum)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)gemm_out_sqrsum)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)gemm_out_sqrsum)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_19; + result_19.type_index = kTVMFFINone; + result_19.zero_padding = 0; + result_19.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_19) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[0]) != 13) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)13; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_20; + result_20.type_index = kTVMFFINone; + result_20.zero_padding = 0; + result_20.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_20) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[1])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_21; + result_21.type_index = kTVMFFINone; + result_21.zero_padding = 0; + result_21.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_21) != 0) { + return -1; + } + } + int32_t condval_4; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides == NULL)) { + condval_4 = 1; + } else { + condval_4 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides)[1]); + } + if ((condval_4 != 1) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_22; + result_22.type_index = kTVMFFINone; + result_22.zero_padding = 0; + result_22.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_22) != 0) { + return -1; + } + } + int32_t condval_5; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides == NULL)) { + condval_5 = 1; + } else { + condval_5 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides)[0]); + } + if ((((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != condval_5) && (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != 0)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_23; + result_23.type_index = kTVMFFINone; + result_23.zero_padding = 0; + result_23.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_23) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)gemm_out_sqrsum)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_24; + result_24.type_index = kTVMFFINone; + result_24.zero_padding = 0; + result_24.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_24) != 0) { + return -1; + } + } + if ((((DLTensor*)gemm_out_sqrsum)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_25; + result_25.type_index = kTVMFFINone; + result_25.zero_padding = 0; + result_25.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_25) != 0) { + return -1; + } + } + if ((((DLTensor*)gemm_out_sqrsum)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_26; + result_26.type_index = kTVMFFINone; + result_26.zero_padding = 0; + result_26.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_26) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (gemm_out_sqrsum_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_27; + result_27.type_index = kTVMFFINone; + result_27.zero_padding = 0; + result_27.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_27) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)hc_scale)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)hc_scale)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)hc_scale)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_28; + result_28.type_index = kTVMFFINone; + result_28.zero_padding = 0; + result_28.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_28) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_shape)[0]) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_29; + result_29.type_index = kTVMFFINone; + result_29.zero_padding = 0; + result_29.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_29) != 0) { + return -1; + } + } + int32_t condval_6; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides == NULL)) { + condval_6 = 1; + } else { + condval_6 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides)[0]); + } + if (condval_6 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_7; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides == NULL)) { + condval_7 = 1; + } else { + condval_7 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides)[0]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_7); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_30; + result_30.type_index = kTVMFFINone; + result_30.zero_padding = 0; + result_30.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_30) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)hc_scale)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_31; + result_31.type_index = kTVMFFINone; + result_31.zero_padding = 0; + result_31.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_31) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_scale)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_32; + result_32.type_index = kTVMFFINone; + result_32.zero_padding = 0; + result_32.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_32) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_scale)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_33; + result_33.type_index = kTVMFFINone; + result_33.zero_padding = 0; + result_33.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_33) != 0) { + return -1; + } + } + if (hc_scale_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_34; + result_34.type_index = kTVMFFINone; + result_34.zero_padding = 0; + result_34.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_34) != 0) { + return -1; + } + } + if ((((((DLTensor*)hc_base)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)hc_base)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)hc_base)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_35; + result_35.type_index = kTVMFFINone; + result_35.zero_padding = 0; + result_35.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_35) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_shape)[0]) != 24) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)24; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_36; + result_36.type_index = kTVMFFINone; + result_36.zero_padding = 0; + result_36.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_36) != 0) { + return -1; + } + } + int32_t condval_8; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides == NULL)) { + condval_8 = 1; + } else { + condval_8 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides)[0]); + } + if (condval_8 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_9; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides == NULL)) { + condval_9 = 1; + } else { + condval_9 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides)[0]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_9); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_37; + result_37.type_index = kTVMFFINone; + result_37.zero_padding = 0; + result_37.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_37) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)hc_base)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_38; + result_38.type_index = kTVMFFINone; + result_38.zero_padding = 0; + result_38.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_38) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_base)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_39; + result_39.type_index = kTVMFFINone; + result_39.zero_padding = 0; + result_39.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_39) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_base)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_40; + result_40.type_index = kTVMFFINone; + result_40.zero_padding = 0; + result_40.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_40) != 0) { + return -1; + } + } + if (hc_base_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_41; + result_41.type_index = kTVMFFINone; + result_41.zero_padding = 0; + result_41.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_41) != 0) { + return -1; + } + } + if ((((((DLTensor*)residual)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)residual)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)residual)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)residual)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)residual)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_42; + result_42.type_index = kTVMFFINone; + result_42.zero_padding = 0; + result_42.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_42) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_43; + result_43.type_index = kTVMFFINone; + result_43.zero_padding = 0; + result_43.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_43) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[1]) != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_44; + result_44.type_index = kTVMFFINone; + result_44.zero_padding = 0; + result_44.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_44) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[2]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[2])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_45; + result_45.type_index = kTVMFFINone; + result_45.zero_padding = 0; + result_45.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_45) != 0) { + return -1; + } + } + int32_t condval_10; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_10 = 1; + } else { + condval_10 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[2]); + } + if (condval_10 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_11; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_11 = 1; + } else { + condval_11 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[2]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_11); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_46; + result_46.type_index = kTVMFFINone; + result_46.zero_padding = 0; + result_46.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_46) != 0) { + return -1; + } + } + int32_t condval_12; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_12 = 1; + } else { + condval_12 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[1]); + } + if (condval_12 != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_13; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_13 = 1; + } else { + condval_13 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_13); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_47; + result_47.type_index = kTVMFFINone; + result_47.zero_padding = 0; + result_47.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_47) != 0) { + return -1; + } + } + int32_t condval_14; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_14 = 1; + } else { + condval_14 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[0]); + } + if ((condval_14 != 16384) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_48; + result_48.type_index = kTVMFFINone; + result_48.zero_padding = 0; + result_48.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_48) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)residual)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_49; + result_49.type_index = kTVMFFINone; + result_49.zero_padding = 0; + result_49.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_49) != 0) { + return -1; + } + } + if ((((DLTensor*)residual)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)residual)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_50; + result_50.type_index = kTVMFFINone; + result_50.zero_padding = 0; + result_50.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_50) != 0) { + return -1; + } + } + if ((((DLTensor*)residual)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_51; + result_51.type_index = kTVMFFINone; + result_51.zero_padding = 0; + result_51.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_51) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (residual_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_52; + result_52.type_index = kTVMFFINone; + result_52.zero_padding = 0; + result_52.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_52) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)post_mix)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)post_mix)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)post_mix)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_53; + result_53.type_index = kTVMFFINone; + result_53.zero_padding = 0; + result_53.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_53) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_54; + result_54.type_index = kTVMFFINone; + result_54.zero_padding = 0; + result_54.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_54) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[1]) != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_55; + result_55.type_index = kTVMFFINone; + result_55.zero_padding = 0; + result_55.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_55) != 0) { + return -1; + } + } + int32_t condval_15; + if ((mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides == NULL)) { + condval_15 = 1; + } else { + condval_15 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides)[1]); + } + if (condval_15 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_16; + if ((mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides == NULL)) { + condval_16 = 1; + } else { + condval_16 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_16); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_56; + result_56.type_index = kTVMFFINone; + result_56.zero_padding = 0; + result_56.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_56) != 0) { + return -1; + } + } + int32_t condval_17; + if ((mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides == NULL)) { + condval_17 = 1; + } else { + condval_17 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides)[0]); + } + if ((condval_17 != 4) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_57; + result_57.type_index = kTVMFFINone; + result_57.zero_padding = 0; + result_57.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_57) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)post_mix)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_58; + result_58.type_index = kTVMFFINone; + result_58.zero_padding = 0; + result_58.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_58) != 0) { + return -1; + } + } + if ((((DLTensor*)post_mix)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_59; + result_59.type_index = kTVMFFINone; + result_59.zero_padding = 0; + result_59.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_59) != 0) { + return -1; + } + } + if ((((DLTensor*)post_mix)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_60; + result_60.type_index = kTVMFFINone; + result_60.zero_padding = 0; + result_60.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_60) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (post_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_61; + result_61.type_index = kTVMFFINone; + result_61.zero_padding = 0; + result_61.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_61) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)comb_mix)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)comb_mix)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)comb_mix)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_62; + result_62.type_index = kTVMFFINone; + result_62.zero_padding = 0; + result_62.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_62) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_63; + result_63.type_index = kTVMFFINone; + result_63.zero_padding = 0; + result_63.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_63) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[1]) != 16) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_64; + result_64.type_index = kTVMFFINone; + result_64.zero_padding = 0; + result_64.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_64) != 0) { + return -1; + } + } + int32_t condval_18; + if ((mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides == NULL)) { + condval_18 = 1; + } else { + condval_18 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides)[1]); + } + if (condval_18 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_19; + if ((mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides == NULL)) { + condval_19 = 1; + } else { + condval_19 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_19); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_65; + result_65.type_index = kTVMFFINone; + result_65.zero_padding = 0; + result_65.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_65) != 0) { + return -1; + } + } + int32_t condval_20; + if ((mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides == NULL)) { + condval_20 = 1; + } else { + condval_20 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides)[0]); + } + if ((condval_20 != 16) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_66; + result_66.type_index = kTVMFFINone; + result_66.zero_padding = 0; + result_66.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_66) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)comb_mix)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_67; + result_67.type_index = kTVMFFINone; + result_67.zero_padding = 0; + result_67.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_67) != 0) { + return -1; + } + } + if ((((DLTensor*)comb_mix)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_68; + result_68.type_index = kTVMFFINone; + result_68.zero_padding = 0; + result_68.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_68) != 0) { + return -1; + } + } + if ((((DLTensor*)comb_mix)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_69; + result_69.type_index = kTVMFFINone; + result_69.zero_padding = 0; + result_69.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_69) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (comb_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_70; + result_70.type_index = kTVMFFINone; + result_70.zero_padding = 0; + result_70.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_70) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)layer_input)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)layer_input)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)layer_input)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_71; + result_71.type_index = kTVMFFINone; + result_71.zero_padding = 0; + result_71.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_71) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_72; + result_72.type_index = kTVMFFINone; + result_72.zero_padding = 0; + result_72.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_72) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[1]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_73; + result_73.type_index = kTVMFFINone; + result_73.zero_padding = 0; + result_73.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_73) != 0) { + return -1; + } + } + int32_t condval_21; + if ((mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides == NULL)) { + condval_21 = 1; + } else { + condval_21 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides)[1]); + } + if (condval_21 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_22; + if ((mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides == NULL)) { + condval_22 = 1; + } else { + condval_22 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_22); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_74; + result_74.type_index = kTVMFFINone; + result_74.zero_padding = 0; + result_74.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_74) != 0) { + return -1; + } + } + int32_t condval_23; + if ((mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides == NULL)) { + condval_23 = 1; + } else { + condval_23 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides)[0]); + } + if ((condval_23 != 4096) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_75; + result_75.type_index = kTVMFFINone; + result_75.zero_padding = 0; + result_75.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_75) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)layer_input)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_76; + result_76.type_index = kTVMFFINone; + result_76.zero_padding = 0; + result_76.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_76) != 0) { + return -1; + } + } + if ((((DLTensor*)layer_input)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_77; + result_77.type_index = kTVMFFINone; + result_77.zero_padding = 0; + result_77.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_77) != 0) { + return -1; + } + } + if ((((DLTensor*)layer_input)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_78; + result_78.type_index = kTVMFFINone; + result_78.zero_padding = 0; + result_78.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_78) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (layer_input_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_79; + result_79.type_index = kTVMFFINone; + result_79.zero_padding = 0; + result_79.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_79) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)norm_weight)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)norm_weight)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)norm_weight)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_80; + result_80.type_index = kTVMFFINone; + result_80.zero_padding = 0; + result_80.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_80) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_shape)[0]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_81; + result_81.type_index = kTVMFFINone; + result_81.zero_padding = 0; + result_81.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_81) != 0) { + return -1; + } + } + int32_t condval_24; + if ((mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides == NULL)) { + condval_24 = 1; + } else { + condval_24 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides)[0]); + } + if (condval_24 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_25; + if ((mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides == NULL)) { + condval_25 = 1; + } else { + condval_25 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides)[0]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_25); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_82; + result_82.type_index = kTVMFFINone; + result_82.zero_padding = 0; + result_82.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_82) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)norm_weight)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_83; + result_83.type_index = kTVMFFINone; + result_83.zero_padding = 0; + result_83.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_83) != 0) { + return -1; + } + } + if ((((DLTensor*)norm_weight)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_84; + result_84.type_index = kTVMFFINone; + result_84.zero_padding = 0; + result_84.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_84) != 0) { + return -1; + } + } + if ((((DLTensor*)norm_weight)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_85; + result_85.type_index = kTVMFFINone; + result_85.zero_padding = 0; + result_85.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_85) != 0) { + return -1; + } + } + if (norm_weight_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_86; + result_86.type_index = kTVMFFINone; + result_86.zero_padding = 0; + result_86.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_86) != 0) { + return -1; + } + } + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = ((int64_t)2); + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = ((int64_t)dev_id); + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + if (__tvm_set_device_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_set_device", &__tvm_set_device_packed) != 0) { + return -1; + } + } + TVMFFIAny result_87; + result_87.type_index = kTVMFFINone; + result_87.zero_padding = 0; + result_87.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_set_device_packed, (TVMFFIAny*) stack_ffi_any, 2, &result_87) != 0) { + return -1; + } + if (comb_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = comb_mix_1; + if (gemm_out_mul_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = gemm_out_mul_1; + if (gemm_out_sqrsum_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = gemm_out_sqrsum_1; + if (hc_base_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_ptr) = hc_base_1; + if (hc_scale_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_ptr) = hc_scale_1; + if (layer_input_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_ptr) = layer_input_1; + if (norm_weight_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_ptr) = norm_weight_1; + if (post_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_ptr) = post_mix_1; + if (residual_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_ptr) = residual_1; + (((TVMFFIAny*)stack_ffi_any)[9].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[9].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[9].v_int64) = ((int64_t)num_tokens); + (((TVMFFIAny*)stack_ffi_any)[10].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[10].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[10].v_int64) = ((int64_t)num_tokens); + (((TVMFFIAny*)stack_ffi_any)[11].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[11].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[11].v_int64) = ((int64_t)96); + (((TVMFFIAny*)stack_ffi_any)[12].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[12].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[12].v_int64) = ((int64_t)1); + (((TVMFFIAny*)stack_ffi_any)[13].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[13].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[13].v_int64) = ((int64_t)1); + (((TVMFFIAny*)stack_ffi_any)[14].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[14].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[14].v_int64) = ((int64_t)29040); + (((TVMFFIAny*)stack_ffi_any)[15].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[15].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[15].v_int64) = (int64_t)0; + if (mhc_pre_big_fuse_with_norm_tilelang_kernel_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "mhc_pre_big_fuse_with_norm_tilelang_kernel", &mhc_pre_big_fuse_with_norm_tilelang_kernel_packed) != 0) { + return -1; + } + } + TVMFFIAny result_88; + result_88.type_index = kTVMFFINone; + result_88.zero_padding = 0; + result_88.v_int64 = 0; + if (TVMFFIFunctionCall(mhc_pre_big_fuse_with_norm_tilelang_kernel_packed, (TVMFFIAny*) stack_ffi_any, 15, &result_88) != 0) { + return -1; + } + return 0; +} + +// CodegenC: NOTE: Auto-generated entry function +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_main(void* self, void* args,int num_args, void* result) { + return __tvm_ffi_mhc_pre_big_fuse_with_norm_tilelang(self, args, num_args, result); +} diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/2f65ba228083b031f9f8b7020d4a171fc67be94c7b476fa6fbe648831cff6878/params.pkl b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/2f65ba228083b031f9f8b7020d4a171fc67be94c7b476fa6fbe648831cff6878/params.pkl new file mode 100644 index 0000000..da26865 Binary files /dev/null and b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/2f65ba228083b031f9f8b7020d4a171fc67be94c7b476fa6fbe648831cff6878/params.pkl differ diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/34141341ae4687b7d5cb99f48bcdb971fae6efe8bba5eed695620f0e86b8bdd4/device_kernel.cu b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/34141341ae4687b7d5cb99f48bcdb971fae6efe8bba5eed695620f0e86b8bdd4/device_kernel.cu new file mode 100644 index 0000000..4e7319d --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/34141341ae4687b7d5cb99f48bcdb971fae6efe8bba5eed695620f0e86b8bdd4/device_kernel.cu @@ -0,0 +1,424 @@ +#include +#include +#include +#include +#include +#include +#include +#ifdef ENABLE_BF16 +#include +#endif + +extern "C" __global__ void mhc_pre_big_fuse_with_norm_tilelang_kernel(float* comb_mix, const float* gemm_out_mul, const float* gemm_out_sqrsum, const float* hc_base, const float* hc_scale, bfloat16_t* layer_input, const bfloat16_t* norm_weight, float* post_mix, const bfloat16_t* residual, int num_tokens); +extern "C" __global__ void __launch_bounds__(96, 1) mhc_pre_big_fuse_with_norm_tilelang_kernel(float* comb_mix, const float* gemm_out_mul, const float* gemm_out_sqrsum, const float* hc_base, const float* hc_scale, bfloat16_t* layer_input, const bfloat16_t* norm_weight, float* post_mix, const bfloat16_t* residual, int num_tokens) { + extern __shared__ __align__(1024) uchar buf_dyn_shmem[]; + float mixes[1]; + float rms[1]; + float cm[1]; + float row_max[1]; + float row_sum[1]; + float col_sum[1]; + float sumsq_per_pos[16]; + float sumsq[1]; + float rsqrt_norm[1]; + float xl[64]; + float ol[16]; + bfloat16_t xs_local_cast[8]; + bfloat16_t xs_local_cast_1[8]; + bfloat16_t xs_local_cast_2[8]; + float w_local[16]; + float ol_1[16]; + bfloat16_t w_shared_local_cast_3[8]; + bfloat16_t output_shared_local_cast_4[8]; + bfloat16_t layer_input_local_cast_5[8]; + bfloat16_t w_shared_local_cast_6[8]; + bfloat16_t output_shared_local_cast_7[8]; + bfloat16_t layer_input_local_cast_8[8]; + bfloat16_t w_shared_local_cast_9[8]; + bfloat16_t output_shared_local_cast_10[8]; + bfloat16_t layer_input_local_cast_11[8]; + mixes[0] = 0x0p+0f/*0.000000e+00*/; + rms[0] = 0x0p+0f/*0.000000e+00*/; + cudaGridDependencySynchronize(); + for (int i_split = 0; i_split < 39; ++i_split) { + rms[0] = (rms[0] + gemm_out_sqrsum[((((int64_t)i_split) * ((int64_t)num_tokens)) + ((int64_t)((int)blockIdx.x)))]); + } + rms[0] = rsqrtf(((rms[0] / 0x1p+14f/*1.638400e+04*/) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + mixes[0] = 0x0p+0f/*0.000000e+00*/; + for (int i_split_1 = 0; i_split_1 < 39; ++i_split_1) { + mixes[0] = (mixes[0] + gemm_out_mul[(((((int64_t)((int)blockIdx.x)) * (int64_t)24) + ((((int64_t)i_split_1) * ((int64_t)num_tokens)) * (int64_t)24)) + (((int64_t)((int)threadIdx.x)) % (int64_t)24))]); + } + mixes[0] = (mixes[0] * rms[0]); + if ((((int)threadIdx.x) / 24) == 0) { + ((float*)buf_dyn_shmem)[(((int)threadIdx.x) % 24)] = mixes[0]; + } + __syncthreads(); + if (((int)threadIdx.x) < 32) { + if (((int)threadIdx.x) < 4) { + post_mix[((((int64_t)((int)blockIdx.x)) * (int64_t)4) + ((int64_t)((int)threadIdx.x)))] = ((0x1p+0f/*1.000000e+00*/ / (0x1p+0f/*1.000000e+00*/ + expf((0x0p+0f/*0.000000e+00*/ - ((((float*)buf_dyn_shmem)[(((int)threadIdx.x) + 4)] * hc_scale[1]) + hc_base[(((int)threadIdx.x) + 4)]))))) * 0x1p+1f/*2.000000e+00*/); + } + cm[0] = ((((float*)buf_dyn_shmem)[((((int)threadIdx.x) & 15) + 8)] * hc_scale[2]) + hc_base[((((int)threadIdx.x) & 15) + 8)]); + row_max[0] = -CUDART_INF_F; + row_max[0] = max(row_max[0], cm[0]); + row_max[0] = tl::AllReduce>::run(row_max[0]); + cm[0] = expf((cm[0] - row_max[0])); + row_sum[0] = 0x0p+0f/*0.000000e+00*/; + row_sum[0] = (row_sum[0] + cm[0]); + row_sum[0] = tl::AllReduce>::run(row_sum[0]); + cm[0] = ((cm[0] / row_sum[0]) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/); + col_sum[0] = 0x0p+0f/*0.000000e+00*/; + col_sum[0] = (col_sum[0] + cm[0]); + col_sum[0] = tl::AllReduce>::run(col_sum[0]); + cm[0] = (cm[0] / (col_sum[0] + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + for (int __1 = 0; __1 < 19; ++__1) { + row_sum[0] = 0x0p+0f/*0.000000e+00*/; + row_sum[0] = (row_sum[0] + cm[0]); + row_sum[0] = tl::AllReduce>::run(row_sum[0]); + cm[0] = (cm[0] / (row_sum[0] + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + col_sum[0] = 0x0p+0f/*0.000000e+00*/; + col_sum[0] = (col_sum[0] + cm[0]); + col_sum[0] = tl::AllReduce>::run(col_sum[0]); + cm[0] = (cm[0] / (col_sum[0] + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + } + if ((((int)threadIdx.x) >> 4) == 0) { + comb_mix[((((int64_t)((int)blockIdx.x)) * (int64_t)16) + (((int64_t)((int)threadIdx.x)) & (int64_t)15))] = cm[0]; + } + } else { + if (((int)threadIdx.x) < 36) { + ((float*)buf_dyn_shmem)[(((int)threadIdx.x) + 7224)] = ((0x1p+0f/*1.000000e+00*/ / (0x1p+0f/*1.000000e+00*/ + expf((0x0p+0f/*0.000000e+00*/ - ((((float*)buf_dyn_shmem)[(((int)threadIdx.x) - 32)] * hc_scale[0]) + hc_base[(((int)threadIdx.x) - 32)]))))) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/); + } + #pragma unroll + for (int i = 0; i < 4; ++i) { + float broadcast_var = 0x0p+0f/*0.000000e+00*/; + *(float4*)(sumsq_per_pos + (i * 4)) = make_float4(broadcast_var, broadcast_var, broadcast_var, broadcast_var); + } + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_1 = 0; i_1 < 8; ++i_1) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i_1 >> 1) * 1024) + (((((i_1 * 64) + ((int)threadIdx.x)) + 96) & 127) * 8)) + 48)])), (&(residual[(((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + ((((int64_t)i_1) >> (int64_t)1) * (int64_t)4096)) + (((((((int64_t)i_1) * (int64_t)64) + ((int64_t)((int)threadIdx.x))) + (int64_t)96) & (int64_t)127) * (int64_t)8))]))); + } + tl::cp_async_commit(); + #pragma unroll + for (int i_2 = 0; i_2 < 8; ++i_2) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i_2 >> 1) * 1024) + (((((i_2 * 64) + ((int)threadIdx.x)) + 96) & 127) * 8)) + 4144)])), (&(residual[((((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + ((((int64_t)i_2) >> (int64_t)1) * (int64_t)4096)) + (((((((int64_t)i_2) * (int64_t)64) + ((int64_t)((int)threadIdx.x))) + (int64_t)96) & (int64_t)127) * (int64_t)8)) + (int64_t)1024)]))); + } + tl::cp_async_commit(); + for (int i0_h = 0; i0_h < 2; ++i0_h) { + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_3 = 0; i_3 < 8; ++i_3) { + *(uint4*)(xs_local_cast + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + ((((i0_h * 4096) + (i_3 * 512)) + (((int)threadIdx.x) * 8)) - 208)); + for (int vec = 0; vec < 2; ++vec) { + float4 __2; + uint2 v_ = *(uint2*)(xs_local_cast + (vec * 4)); + ((float2*)(&__2))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v_))[0]); + ((float2*)(&__2))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v_))[1]); + *(float4*)(xl + ((i_3 * 8) + (vec * 4))) = __2; + } + } + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_4 = 0; i_4 < 8; ++i_4) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i0_h * 4096) + ((i_4 >> 1) * 1024)) + (((((i_4 * 64) + ((int)threadIdx.x)) + 96) & 127) * 8)) + 48)])), (&(residual[(((((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + ((((int64_t)i_4) >> (int64_t)1) * (int64_t)4096)) + (((int64_t)i0_h) * (int64_t)1024)) + (((((((int64_t)i_4) * (int64_t)64) + ((int64_t)((int)threadIdx.x))) + (int64_t)96) & (int64_t)127) * (int64_t)8)) + (int64_t)2048)]))); + } + tl::cp_async_commit(); + #pragma unroll + for (int i_5 = 0; i_5 < 4; ++i_5) { + float broadcast_var_1 = 0x0p+0f/*0.000000e+00*/; + *(float4*)(ol + (i_5 * 4)) = make_float4(broadcast_var_1, broadcast_var_1, broadcast_var_1, broadcast_var_1); + } + tl::__sync_thread_partial<3, 64>(); + for (int i_hc = 0; i_hc < 4; ++i_hc) { + float pre = ((float*)buf_dyn_shmem)[(i_hc + 7256)]; + #pragma unroll + for (int i_6 = 0; i_6 < 16; ++i_6) { + ol[i_6] = (ol[i_6] + (pre * xl[((i_hc * 16) + i_6)])); + } + } + #pragma unroll + for (int i_7 = 0; i_7 < 4; ++i_7) { + float4 __3; + float4 v__1 = *(float4*)(sumsq_per_pos + (i_7 * 4)); + float4 __4; + float4 v__2 = *(float4*)(ol + (i_7 * 4)); + __4.x = (v__2.x*v__2.x); + __4.y = (v__2.y*v__2.y); + __4.z = (v__2.z*v__2.z); + __4.w = (v__2.w*v__2.w); + __3.x = (v__1.x+__4.x); + __3.y = (v__1.y+__4.y); + __3.z = (v__1.z+__4.z); + __3.w = (v__1.w+__4.w); + *(float4*)(sumsq_per_pos + (i_7 * 4)) = __3; + uint2 __5; + float4 v__3 = *(float4*)(ol + (i_7 * 4)); + (reinterpret_cast<__nv_bfloat162*>(&__5))[0] = __float22bfloat162_rn(((float2*)(&v__3))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__5))[1] = __float22bfloat162_rn(((float2*)(&v__3))[1]); + *(uint2*)(((bfloat16_t*)buf_dyn_shmem) + (((((i0_h * 1024) + ((i_7 >> 1) * 512)) + (((int)threadIdx.x) * 8)) + ((i_7 & 1) * 4)) + 7984)) = __5; + } + } + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_8 = 0; i_8 < 8; ++i_8) { + *(uint4*)(xs_local_cast_1 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_8 * 512) + (((int)threadIdx.x) * 8)) - 208)); + for (int vec_1 = 0; vec_1 < 2; ++vec_1) { + float4 __6; + uint2 v__4 = *(uint2*)(xs_local_cast_1 + (vec_1 * 4)); + ((float2*)(&__6))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__4))[0]); + ((float2*)(&__6))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__4))[1]); + *(float4*)(xl + ((i_8 * 8) + (vec_1 * 4))) = __6; + } + } + #pragma unroll + for (int i_9 = 0; i_9 < 4; ++i_9) { + float broadcast_var_2 = 0x0p+0f/*0.000000e+00*/; + *(float4*)(ol + (i_9 * 4)) = make_float4(broadcast_var_2, broadcast_var_2, broadcast_var_2, broadcast_var_2); + } + for (int i_hc_1 = 0; i_hc_1 < 4; ++i_hc_1) { + float pre_1 = ((float*)buf_dyn_shmem)[(i_hc_1 + 7256)]; + #pragma unroll + for (int i_10 = 0; i_10 < 16; ++i_10) { + ol[i_10] = (ol[i_10] + (pre_1 * xl[((i_hc_1 * 16) + i_10)])); + } + } + #pragma unroll + for (int i_11 = 0; i_11 < 4; ++i_11) { + float4 __7; + float4 v__5 = *(float4*)(sumsq_per_pos + (i_11 * 4)); + float4 __8; + float4 v__6 = *(float4*)(ol + (i_11 * 4)); + __8.x = (v__6.x*v__6.x); + __8.y = (v__6.y*v__6.y); + __8.z = (v__6.z*v__6.z); + __8.w = (v__6.w*v__6.w); + __7.x = (v__5.x+__8.x); + __7.y = (v__5.y+__8.y); + __7.z = (v__5.z+__8.z); + __7.w = (v__5.w+__8.w); + *(float4*)(sumsq_per_pos + (i_11 * 4)) = __7; + uint2 __9; + float4 v__7 = *(float4*)(ol + (i_11 * 4)); + (reinterpret_cast<__nv_bfloat162*>(&__9))[0] = __float22bfloat162_rn(((float2*)(&v__7))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__9))[1] = __float22bfloat162_rn(((float2*)(&v__7))[1]); + *(uint2*)(((bfloat16_t*)buf_dyn_shmem) + (((((i_11 >> 1) * 512) + (((int)threadIdx.x) * 8)) + ((i_11 & 1) * 4)) + 10032)) = __9; + } + tl::cp_async_wait<0>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_12 = 0; i_12 < 8; ++i_12) { + *(uint4*)(xs_local_cast_2 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_12 * 512) + (((int)threadIdx.x) * 8)) + 3888)); + for (int vec_2 = 0; vec_2 < 2; ++vec_2) { + float4 __10; + uint2 v__8 = *(uint2*)(xs_local_cast_2 + (vec_2 * 4)); + ((float2*)(&__10))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__8))[0]); + ((float2*)(&__10))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__8))[1]); + *(float4*)(xl + ((i_12 * 8) + (vec_2 * 4))) = __10; + } + } + #pragma unroll + for (int i_13 = 0; i_13 < 4; ++i_13) { + float broadcast_var_3 = 0x0p+0f/*0.000000e+00*/; + *(float4*)(ol + (i_13 * 4)) = make_float4(broadcast_var_3, broadcast_var_3, broadcast_var_3, broadcast_var_3); + } + for (int i_hc_2 = 0; i_hc_2 < 4; ++i_hc_2) { + float pre_2 = ((float*)buf_dyn_shmem)[(i_hc_2 + 7256)]; + #pragma unroll + for (int i_14 = 0; i_14 < 16; ++i_14) { + ol[i_14] = (ol[i_14] + (pre_2 * xl[((i_hc_2 * 16) + i_14)])); + } + } + #pragma unroll + for (int i_15 = 0; i_15 < 4; ++i_15) { + float4 __11; + float4 v__9 = *(float4*)(sumsq_per_pos + (i_15 * 4)); + float4 __12; + float4 v__10 = *(float4*)(ol + (i_15 * 4)); + __12.x = (v__10.x*v__10.x); + __12.y = (v__10.y*v__10.y); + __12.z = (v__10.z*v__10.z); + __12.w = (v__10.w*v__10.w); + __11.x = (v__9.x+__12.x); + __11.y = (v__9.y+__12.y); + __11.z = (v__9.z+__12.z); + __11.w = (v__9.w+__12.w); + *(float4*)(sumsq_per_pos + (i_15 * 4)) = __11; + uint2 __13; + float4 v__11 = *(float4*)(ol + (i_15 * 4)); + (reinterpret_cast<__nv_bfloat162*>(&__13))[0] = __float22bfloat162_rn(((float2*)(&v__11))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__13))[1] = __float22bfloat162_rn(((float2*)(&v__11))[1]); + *(uint2*)(((bfloat16_t*)buf_dyn_shmem) + (((((i_15 >> 1) * 512) + (((int)threadIdx.x) * 8)) + ((i_15 & 1) * 4)) + 11056)) = __13; + } + sumsq[0] = 0x0p+0f/*0.000000e+00*/; + #pragma unroll + for (int rv = 0; rv < 16; ++rv) { + sumsq[0] = (sumsq[0] + sumsq_per_pos[(((rv & 1) * 8) + (rv >> 1))]); + } + tl::__sync_thread_partial<3, 64>(); + sumsq[0] = tl::AllReduce>::run(sumsq[0], (&(((float*)buf_dyn_shmem)[7192]))); + rsqrt_norm[0] = rsqrtf(((sumsq[0] / 0x1p+12f/*4.096000e+03*/) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + #pragma unroll + for (int i_16 = 0; i_16 < 2; ++i_16) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[(((i_16 * 512) + (((int)threadIdx.x) * 8)) + 12080)])), (&(norm_weight[(((i_16 * 512) + (((int)threadIdx.x) * 8)) - 256)]))); + } + tl::cp_async_commit(); + #pragma unroll + for (int i_17 = 0; i_17 < 2; ++i_17) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[(((i_17 * 512) + (((int)threadIdx.x) * 8)) + 13104)])), (&(norm_weight[(((i_17 * 512) + (((int)threadIdx.x) * 8)) + 768)]))); + } + tl::cp_async_commit(); + for (int i0_h_1 = 0; i0_h_1 < 2; ++i0_h_1) { + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_18 = 0; i_18 < 2; ++i_18) { + *(uint4*)(w_shared_local_cast_3 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + ((((i0_h_1 * 1024) + (i_18 * 512)) + (((int)threadIdx.x) * 8)) + 12080)); + for (int vec_3 = 0; vec_3 < 2; ++vec_3) { + float4 __14; + uint2 v__12 = *(uint2*)(w_shared_local_cast_3 + (vec_3 * 4)); + ((float2*)(&__14))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__12))[0]); + ((float2*)(&__14))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__12))[1]); + *(float4*)(w_local + ((i_18 * 8) + (vec_3 * 4))) = __14; + } + } + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_19 = 0; i_19 < 2; ++i_19) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i0_h_1 * 1024) + (i_19 * 512)) + (((int)threadIdx.x) * 8)) + 12080)])), (&(norm_weight[((((i0_h_1 * 1024) + (i_19 * 512)) + (((int)threadIdx.x) * 8)) + 1792)]))); + } + tl::cp_async_commit(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_20 = 0; i_20 < 2; ++i_20) { + *(uint4*)(output_shared_local_cast_4 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + ((((i0_h_1 * 1024) + (i_20 * 512)) + (((int)threadIdx.x) * 8)) + 7984)); + for (int vec_4 = 0; vec_4 < 2; ++vec_4) { + float4 __15; + float4 __16; + float4 __17; + uint2 v__13 = *(uint2*)(output_shared_local_cast_4 + (vec_4 * 4)); + ((float2*)(&__17))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__13))[0]); + ((float2*)(&__17))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__13))[1]); + float4 v__14 = make_float4(rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0]); + __16.x = (__17.x*v__14.x); + __16.y = (__17.y*v__14.y); + __16.z = (__17.z*v__14.z); + __16.w = (__17.w*v__14.w); + float4 v__15 = *(float4*)(w_local + ((i_20 * 8) + (vec_4 * 4))); + __15.x = (__16.x*v__15.x); + __15.y = (__16.y*v__15.y); + __15.z = (__16.z*v__15.z); + __15.w = (__16.w*v__15.w); + *(float4*)(ol_1 + ((i_20 * 8) + (vec_4 * 4))) = __15; + } + } + #pragma unroll + for (int i_21 = 0; i_21 < 2; ++i_21) { + for (int vec_5 = 0; vec_5 < 2; ++vec_5) { + uint2 __18; + float4 v__16 = *(float4*)(ol_1 + ((i_21 * 8) + (vec_5 * 4))); + (reinterpret_cast<__nv_bfloat162*>(&__18))[0] = __float22bfloat162_rn(((float2*)(&v__16))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__18))[1] = __float22bfloat162_rn(((float2*)(&v__16))[1]); + *(uint2*)(layer_input_local_cast_5 + (vec_5 * 4)) = __18; + } + *(uint4*)(layer_input + (((((((int64_t)((int)blockIdx.x)) * (int64_t)4096) + (((int64_t)i0_h_1) * (int64_t)1024)) + (((int64_t)i_21) * (int64_t)512)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8)) - (int64_t)256)) = *(uint4*)(layer_input_local_cast_5 + 0); + } + } + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_22 = 0; i_22 < 2; ++i_22) { + *(uint4*)(w_shared_local_cast_6 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_22 * 512) + (((int)threadIdx.x) * 8)) + 12080)); + for (int vec_6 = 0; vec_6 < 2; ++vec_6) { + float4 __19; + uint2 v__17 = *(uint2*)(w_shared_local_cast_6 + (vec_6 * 4)); + ((float2*)(&__19))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__17))[0]); + ((float2*)(&__19))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__17))[1]); + *(float4*)(w_local + ((i_22 * 8) + (vec_6 * 4))) = __19; + } + } + #pragma unroll + for (int i_23 = 0; i_23 < 2; ++i_23) { + *(uint4*)(output_shared_local_cast_7 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_23 * 512) + (((int)threadIdx.x) * 8)) + 10032)); + for (int vec_7 = 0; vec_7 < 2; ++vec_7) { + float4 __20; + float4 __21; + float4 __22; + uint2 v__18 = *(uint2*)(output_shared_local_cast_7 + (vec_7 * 4)); + ((float2*)(&__22))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__18))[0]); + ((float2*)(&__22))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__18))[1]); + float4 v__19 = make_float4(rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0]); + __21.x = (__22.x*v__19.x); + __21.y = (__22.y*v__19.y); + __21.z = (__22.z*v__19.z); + __21.w = (__22.w*v__19.w); + float4 v__20 = *(float4*)(w_local + ((i_23 * 8) + (vec_7 * 4))); + __20.x = (__21.x*v__20.x); + __20.y = (__21.y*v__20.y); + __20.z = (__21.z*v__20.z); + __20.w = (__21.w*v__20.w); + *(float4*)(ol_1 + ((i_23 * 8) + (vec_7 * 4))) = __20; + } + } + #pragma unroll + for (int i_24 = 0; i_24 < 2; ++i_24) { + for (int vec_8 = 0; vec_8 < 2; ++vec_8) { + uint2 __23; + float4 v__21 = *(float4*)(ol_1 + ((i_24 * 8) + (vec_8 * 4))); + (reinterpret_cast<__nv_bfloat162*>(&__23))[0] = __float22bfloat162_rn(((float2*)(&v__21))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__23))[1] = __float22bfloat162_rn(((float2*)(&v__21))[1]); + *(uint2*)(layer_input_local_cast_8 + (vec_8 * 4)) = __23; + } + *(uint4*)(layer_input + ((((((int64_t)((int)blockIdx.x)) * (int64_t)4096) + (((int64_t)i_24) * (int64_t)512)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8)) + (int64_t)1792)) = *(uint4*)(layer_input_local_cast_8 + 0); + } + tl::cp_async_wait<0>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_25 = 0; i_25 < 2; ++i_25) { + *(uint4*)(w_shared_local_cast_9 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_25 * 512) + (((int)threadIdx.x) * 8)) + 13104)); + for (int vec_9 = 0; vec_9 < 2; ++vec_9) { + float4 __24; + uint2 v__22 = *(uint2*)(w_shared_local_cast_9 + (vec_9 * 4)); + ((float2*)(&__24))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__22))[0]); + ((float2*)(&__24))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__22))[1]); + *(float4*)(w_local + ((i_25 * 8) + (vec_9 * 4))) = __24; + } + } + #pragma unroll + for (int i_26 = 0; i_26 < 2; ++i_26) { + *(uint4*)(output_shared_local_cast_10 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_26 * 512) + (((int)threadIdx.x) * 8)) + 11056)); + for (int vec_10 = 0; vec_10 < 2; ++vec_10) { + float4 __25; + float4 __26; + float4 __27; + uint2 v__23 = *(uint2*)(output_shared_local_cast_10 + (vec_10 * 4)); + ((float2*)(&__27))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__23))[0]); + ((float2*)(&__27))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__23))[1]); + float4 v__24 = make_float4(rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0]); + __26.x = (__27.x*v__24.x); + __26.y = (__27.y*v__24.y); + __26.z = (__27.z*v__24.z); + __26.w = (__27.w*v__24.w); + float4 v__25 = *(float4*)(w_local + ((i_26 * 8) + (vec_10 * 4))); + __25.x = (__26.x*v__25.x); + __25.y = (__26.y*v__25.y); + __25.z = (__26.z*v__25.z); + __25.w = (__26.w*v__25.w); + *(float4*)(ol_1 + ((i_26 * 8) + (vec_10 * 4))) = __25; + } + } + #pragma unroll + for (int i_27 = 0; i_27 < 2; ++i_27) { + for (int vec_11 = 0; vec_11 < 2; ++vec_11) { + uint2 __28; + float4 v__26 = *(float4*)(ol_1 + ((i_27 * 8) + (vec_11 * 4))); + (reinterpret_cast<__nv_bfloat162*>(&__28))[0] = __float22bfloat162_rn(((float2*)(&v__26))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__28))[1] = __float22bfloat162_rn(((float2*)(&v__26))[1]); + *(uint2*)(layer_input_local_cast_11 + (vec_11 * 4)) = __28; + } + *(uint4*)(layer_input + ((((((int64_t)((int)blockIdx.x)) * (int64_t)4096) + (((int64_t)i_27) * (int64_t)512)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8)) + (int64_t)2816)) = *(uint4*)(layer_input_local_cast_11 + 0); + } + } + cudaTriggerProgrammaticLaunchCompletion(); +} + diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/34141341ae4687b7d5cb99f48bcdb971fae6efe8bba5eed695620f0e86b8bdd4/host_kernel.cu b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/34141341ae4687b7d5cb99f48bcdb971fae6efe8bba5eed695620f0e86b8bdd4/host_kernel.cu new file mode 100644 index 0000000..0b74380 --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/34141341ae4687b7d5cb99f48bcdb971fae6efe8bba5eed695620f0e86b8bdd4/host_kernel.cu @@ -0,0 +1,3359 @@ +// tilelang target: c -keys=cpu +#define TVM_EXPORTS +#include "tvm/runtime/base.h" +#include "tvm/runtime/c_backend_api.h" +#include "tvm/ffi/c_api.h" +#include +#include +#include +#ifdef __OBJC__ +#include "tvm/runtime/device_api.h" +#include "tvm/ffi/function.h" +#include +#include +#include +#endif +void* __tvm_ffi__library_ctx = NULL; +static void* __tvm_error_ndim_mismatch_packed = NULL; +static void* __tvm_error_dtype_mismatch_packed = NULL; +static void* __tvm_error_expect_eq_packed = NULL; +static void* __tvm_error_constraint_violation_packed = NULL; +static void* __tvm_error_byte_offset_mismatch_packed = NULL; +static void* __tvm_error_device_type_mismatch_packed = NULL; +static void* __tvm_error_null_ptr_packed = NULL; +static void* __tvm_set_device_packed = NULL; +static void* mhc_pre_big_fuse_with_norm_tilelang_kernel_packed = NULL; +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_mhc_pre_big_fuse_with_norm_tilelang(void* self_handle, void* args, int32_t num_args, void* result); +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_mhc_pre_big_fuse_with_norm_tilelang(void* self_handle, void* args, int32_t num_args, void* result) { + __attribute__((aligned(64))) TVMFFIAny stack[16]; + void* stack_ffi_any = stack; + if (!((num_args == 9))) { + char __tvm_assert_msg_buf[512]; + snprintf(__tvm_assert_msg_buf, 512, "%s; expected: %lld, got: %lld", "mhc_pre_big_fuse_with_norm_tilelang: num_args should be 9", (long long)(num_args), (long long)(9)); + TVMFFIErrorSetRaisedFromCStr("RuntimeError", __tvm_assert_msg_buf); + return -1; + } + if (!(!(args == NULL))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang: args pointer is NULL"); + return -1; + } + int32_t gemm_out_mul_type_index = (((TVMFFIAny*)args)[0].type_index); + if (!(((((gemm_out_mul_type_index == 0) || (gemm_out_mul_type_index == 4)) || (gemm_out_mul_type_index == 7)) || (64 <= gemm_out_mul_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input gemm_out_mul expected pointer or tensor handle"); + return -1; + } + int32_t gemm_out_sqrsum_type_index = (((TVMFFIAny*)args)[1].type_index); + if (!(((((gemm_out_sqrsum_type_index == 0) || (gemm_out_sqrsum_type_index == 4)) || (gemm_out_sqrsum_type_index == 7)) || (64 <= gemm_out_sqrsum_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input gemm_out_sqrsum expected pointer or tensor handle"); + return -1; + } + int32_t hc_scale_type_index = (((TVMFFIAny*)args)[2].type_index); + if (!(((((hc_scale_type_index == 0) || (hc_scale_type_index == 4)) || (hc_scale_type_index == 7)) || (64 <= hc_scale_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input hc_scale expected pointer or tensor handle"); + return -1; + } + int32_t hc_base_type_index = (((TVMFFIAny*)args)[3].type_index); + if (!(((((hc_base_type_index == 0) || (hc_base_type_index == 4)) || (hc_base_type_index == 7)) || (64 <= hc_base_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input hc_base expected pointer or tensor handle"); + return -1; + } + int32_t residual_type_index = (((TVMFFIAny*)args)[4].type_index); + if (!(((((residual_type_index == 0) || (residual_type_index == 4)) || (residual_type_index == 7)) || (64 <= residual_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input residual expected pointer or tensor handle"); + return -1; + } + int32_t post_mix_type_index = (((TVMFFIAny*)args)[5].type_index); + if (!(((((post_mix_type_index == 0) || (post_mix_type_index == 4)) || (post_mix_type_index == 7)) || (64 <= post_mix_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input post_mix expected pointer or tensor handle"); + return -1; + } + int32_t comb_mix_type_index = (((TVMFFIAny*)args)[6].type_index); + if (!(((((comb_mix_type_index == 0) || (comb_mix_type_index == 4)) || (comb_mix_type_index == 7)) || (64 <= comb_mix_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input comb_mix expected pointer or tensor handle"); + return -1; + } + int32_t layer_input_type_index = (((TVMFFIAny*)args)[7].type_index); + if (!(((((layer_input_type_index == 0) || (layer_input_type_index == 4)) || (layer_input_type_index == 7)) || (64 <= layer_input_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input layer_input expected pointer or tensor handle"); + return -1; + } + int32_t norm_weight_type_index = (((TVMFFIAny*)args)[8].type_index); + if (!(((((norm_weight_type_index == 0) || (norm_weight_type_index == 4)) || (norm_weight_type_index == 7)) || (64 <= norm_weight_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input norm_weight expected pointer or tensor handle"); + return -1; + } + void* gemm_out_mul = ((gemm_out_mul_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[0].v_ptr) + 24)) : (((TVMFFIAny*)args)[0].v_ptr)); + void* gemm_out_sqrsum = ((gemm_out_sqrsum_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[1].v_ptr) + 24)) : (((TVMFFIAny*)args)[1].v_ptr)); + void* hc_scale = ((hc_scale_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[2].v_ptr) + 24)) : (((TVMFFIAny*)args)[2].v_ptr)); + void* hc_base = ((hc_base_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[3].v_ptr) + 24)) : (((TVMFFIAny*)args)[3].v_ptr)); + void* residual = ((residual_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[4].v_ptr) + 24)) : (((TVMFFIAny*)args)[4].v_ptr)); + void* post_mix = ((post_mix_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[5].v_ptr) + 24)) : (((TVMFFIAny*)args)[5].v_ptr)); + void* comb_mix = ((comb_mix_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[6].v_ptr) + 24)) : (((TVMFFIAny*)args)[6].v_ptr)); + void* layer_input = ((layer_input_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[7].v_ptr) + 24)) : (((TVMFFIAny*)args)[7].v_ptr)); + void* norm_weight = ((norm_weight_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[8].v_ptr) + 24)) : (((TVMFFIAny*)args)[8].v_ptr)); + bool mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_is_null = (gemm_out_mul == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.gemm_out_mul is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_is_null = (gemm_out_sqrsum == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.gemm_out_sqrsum is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_hc_scale_is_null = (hc_scale == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_hc_scale_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.hc_scale is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_hc_base_is_null = (hc_base == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_hc_base_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.hc_base is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_residual_is_null = (residual == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_residual_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.residual is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_post_mix_is_null = (post_mix == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_post_mix_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.post_mix is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_comb_mix_is_null = (comb_mix == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_comb_mix_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.comb_mix is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_layer_input_is_null = (layer_input == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_layer_input_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.layer_input is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_norm_weight_is_null = (norm_weight == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_norm_weight_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.norm_weight is expected to have non-NULL pointer"); + return -1; + } + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape = (((DLTensor*)gemm_out_mul)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape = (((DLTensor*)gemm_out_sqrsum)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_hc_scale_shape = (((DLTensor*)hc_scale)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_hc_base_shape = (((DLTensor*)hc_base)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_residual_shape = (((DLTensor*)residual)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape = (((DLTensor*)post_mix)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape = (((DLTensor*)comb_mix)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape = (((DLTensor*)layer_input)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_norm_weight_shape = (((DLTensor*)norm_weight)[0].shape); + if ((((DLTensor*)gemm_out_mul)[0].ndim) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_1; + result_1.type_index = kTVMFFINone; + result_1.zero_padding = 0; + result_1.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_1) != 0) { + return -1; + } + } + if (!((bool)1)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "Symbolic shape variable num_tokens requires at least one non-null buffer among: mhc_pre_big_fuse_with_norm_tilelang.gemm_out_mul, mhc_pre_big_fuse_with_norm_tilelang.gemm_out_sqrsum, mhc_pre_big_fuse_with_norm_tilelang.residual, mhc_pre_big_fuse_with_norm_tilelang.post_mix, mhc_pre_big_fuse_with_norm_tilelang.comb_mix, mhc_pre_big_fuse_with_norm_tilelang.layer_input"); + return -1; + } + int32_t num_tokens = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]); + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides = (((DLTensor*)gemm_out_mul)[0].strides); + int32_t dev_id = (((DLTensor*)gemm_out_mul)[0].device.device_id); + void* gemm_out_mul_1 = (((DLTensor*)gemm_out_mul)[0].data); + if ((((DLTensor*)gemm_out_sqrsum)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_2; + result_2.type_index = kTVMFFINone; + result_2.zero_padding = 0; + result_2.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_2) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides = (((DLTensor*)gemm_out_sqrsum)[0].strides); + void* gemm_out_sqrsum_1 = (((DLTensor*)gemm_out_sqrsum)[0].data); + if ((((DLTensor*)hc_scale)[0].ndim) != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_3; + result_3.type_index = kTVMFFINone; + result_3.zero_padding = 0; + result_3.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_3) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides = (((DLTensor*)hc_scale)[0].strides); + void* hc_scale_1 = (((DLTensor*)hc_scale)[0].data); + if ((((DLTensor*)hc_base)[0].ndim) != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_4; + result_4.type_index = kTVMFFINone; + result_4.zero_padding = 0; + result_4.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_4) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides = (((DLTensor*)hc_base)[0].strides); + void* hc_base_1 = (((DLTensor*)hc_base)[0].data); + if ((((DLTensor*)residual)[0].ndim) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_5; + result_5.type_index = kTVMFFINone; + result_5.zero_padding = 0; + result_5.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_5) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_residual_strides = (((DLTensor*)residual)[0].strides); + void* residual_1 = (((DLTensor*)residual)[0].data); + if ((((DLTensor*)post_mix)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_6; + result_6.type_index = kTVMFFINone; + result_6.zero_padding = 0; + result_6.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_6) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides = (((DLTensor*)post_mix)[0].strides); + void* post_mix_1 = (((DLTensor*)post_mix)[0].data); + if ((((DLTensor*)comb_mix)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_7; + result_7.type_index = kTVMFFINone; + result_7.zero_padding = 0; + result_7.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_7) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides = (((DLTensor*)comb_mix)[0].strides); + void* comb_mix_1 = (((DLTensor*)comb_mix)[0].data); + if ((((DLTensor*)layer_input)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_8; + result_8.type_index = kTVMFFINone; + result_8.zero_padding = 0; + result_8.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_8) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides = (((DLTensor*)layer_input)[0].strides); + void* layer_input_1 = (((DLTensor*)layer_input)[0].data); + if ((((DLTensor*)norm_weight)[0].ndim) != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_9; + result_9.type_index = kTVMFFINone; + result_9.zero_padding = 0; + result_9.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_9) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides = (((DLTensor*)norm_weight)[0].strides); + void* norm_weight_1 = (((DLTensor*)norm_weight)[0].data); + if ((((((DLTensor*)gemm_out_mul)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)gemm_out_mul)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)gemm_out_mul)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_10; + result_10.type_index = kTVMFFINone; + result_10.zero_padding = 0; + result_10.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_10) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[0]) != 39) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)39; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_11; + result_11.type_index = kTVMFFINone; + result_11.zero_padding = 0; + result_11.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_11) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[2]) != 24) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)24; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[2])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_12; + result_12.type_index = kTVMFFINone; + result_12.zero_padding = 0; + result_12.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_12) != 0) { + return -1; + } + } + int32_t condval; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval = 1; + } else { + condval = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[2]); + } + if (condval != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_1; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval_1 = 1; + } else { + condval_1 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[2]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_1); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_13; + result_13.type_index = kTVMFFINone; + result_13.zero_padding = 0; + result_13.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_13) != 0) { + return -1; + } + } + int32_t condval_2; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval_2 = 1; + } else { + condval_2 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[1]); + } + if ((condval_2 != 24) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_14; + result_14.type_index = kTVMFFINone; + result_14.zero_padding = 0; + result_14.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_14) != 0) { + return -1; + } + } + int32_t condval_3; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval_3 = 1; + } else { + condval_3 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[0]); + } + if (((num_tokens * 24) != condval_3) && (num_tokens != 0)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_15; + result_15.type_index = kTVMFFINone; + result_15.zero_padding = 0; + result_15.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_15) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)gemm_out_mul)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_16; + result_16.type_index = kTVMFFINone; + result_16.zero_padding = 0; + result_16.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_16) != 0) { + return -1; + } + } + if ((((DLTensor*)gemm_out_mul)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_17; + result_17.type_index = kTVMFFINone; + result_17.zero_padding = 0; + result_17.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_17) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (gemm_out_mul_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_18; + result_18.type_index = kTVMFFINone; + result_18.zero_padding = 0; + result_18.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_18) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)gemm_out_sqrsum)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)gemm_out_sqrsum)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)gemm_out_sqrsum)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_19; + result_19.type_index = kTVMFFINone; + result_19.zero_padding = 0; + result_19.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_19) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[0]) != 39) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)39; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_20; + result_20.type_index = kTVMFFINone; + result_20.zero_padding = 0; + result_20.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_20) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[1])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_21; + result_21.type_index = kTVMFFINone; + result_21.zero_padding = 0; + result_21.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_21) != 0) { + return -1; + } + } + int32_t condval_4; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides == NULL)) { + condval_4 = 1; + } else { + condval_4 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides)[1]); + } + if ((condval_4 != 1) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_22; + result_22.type_index = kTVMFFINone; + result_22.zero_padding = 0; + result_22.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_22) != 0) { + return -1; + } + } + int32_t condval_5; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides == NULL)) { + condval_5 = 1; + } else { + condval_5 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides)[0]); + } + if ((((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != condval_5) && (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != 0)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_23; + result_23.type_index = kTVMFFINone; + result_23.zero_padding = 0; + result_23.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_23) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)gemm_out_sqrsum)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_24; + result_24.type_index = kTVMFFINone; + result_24.zero_padding = 0; + result_24.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_24) != 0) { + return -1; + } + } + if ((((DLTensor*)gemm_out_sqrsum)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_25; + result_25.type_index = kTVMFFINone; + result_25.zero_padding = 0; + result_25.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_25) != 0) { + return -1; + } + } + if ((((DLTensor*)gemm_out_sqrsum)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_26; + result_26.type_index = kTVMFFINone; + result_26.zero_padding = 0; + result_26.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_26) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (gemm_out_sqrsum_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_27; + result_27.type_index = kTVMFFINone; + result_27.zero_padding = 0; + result_27.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_27) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)hc_scale)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)hc_scale)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)hc_scale)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_28; + result_28.type_index = kTVMFFINone; + result_28.zero_padding = 0; + result_28.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_28) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_shape)[0]) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_29; + result_29.type_index = kTVMFFINone; + result_29.zero_padding = 0; + result_29.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_29) != 0) { + return -1; + } + } + int32_t condval_6; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides == NULL)) { + condval_6 = 1; + } else { + condval_6 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides)[0]); + } + if (condval_6 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_7; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides == NULL)) { + condval_7 = 1; + } else { + condval_7 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides)[0]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_7); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_30; + result_30.type_index = kTVMFFINone; + result_30.zero_padding = 0; + result_30.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_30) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)hc_scale)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_31; + result_31.type_index = kTVMFFINone; + result_31.zero_padding = 0; + result_31.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_31) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_scale)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_32; + result_32.type_index = kTVMFFINone; + result_32.zero_padding = 0; + result_32.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_32) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_scale)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_33; + result_33.type_index = kTVMFFINone; + result_33.zero_padding = 0; + result_33.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_33) != 0) { + return -1; + } + } + if (hc_scale_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_34; + result_34.type_index = kTVMFFINone; + result_34.zero_padding = 0; + result_34.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_34) != 0) { + return -1; + } + } + if ((((((DLTensor*)hc_base)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)hc_base)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)hc_base)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_35; + result_35.type_index = kTVMFFINone; + result_35.zero_padding = 0; + result_35.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_35) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_shape)[0]) != 24) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)24; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_36; + result_36.type_index = kTVMFFINone; + result_36.zero_padding = 0; + result_36.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_36) != 0) { + return -1; + } + } + int32_t condval_8; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides == NULL)) { + condval_8 = 1; + } else { + condval_8 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides)[0]); + } + if (condval_8 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_9; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides == NULL)) { + condval_9 = 1; + } else { + condval_9 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides)[0]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_9); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_37; + result_37.type_index = kTVMFFINone; + result_37.zero_padding = 0; + result_37.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_37) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)hc_base)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_38; + result_38.type_index = kTVMFFINone; + result_38.zero_padding = 0; + result_38.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_38) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_base)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_39; + result_39.type_index = kTVMFFINone; + result_39.zero_padding = 0; + result_39.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_39) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_base)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_40; + result_40.type_index = kTVMFFINone; + result_40.zero_padding = 0; + result_40.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_40) != 0) { + return -1; + } + } + if (hc_base_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_41; + result_41.type_index = kTVMFFINone; + result_41.zero_padding = 0; + result_41.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_41) != 0) { + return -1; + } + } + if ((((((DLTensor*)residual)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)residual)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)residual)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)residual)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)residual)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_42; + result_42.type_index = kTVMFFINone; + result_42.zero_padding = 0; + result_42.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_42) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_43; + result_43.type_index = kTVMFFINone; + result_43.zero_padding = 0; + result_43.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_43) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[1]) != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_44; + result_44.type_index = kTVMFFINone; + result_44.zero_padding = 0; + result_44.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_44) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[2]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[2])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_45; + result_45.type_index = kTVMFFINone; + result_45.zero_padding = 0; + result_45.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_45) != 0) { + return -1; + } + } + int32_t condval_10; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_10 = 1; + } else { + condval_10 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[2]); + } + if (condval_10 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_11; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_11 = 1; + } else { + condval_11 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[2]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_11); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_46; + result_46.type_index = kTVMFFINone; + result_46.zero_padding = 0; + result_46.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_46) != 0) { + return -1; + } + } + int32_t condval_12; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_12 = 1; + } else { + condval_12 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[1]); + } + if (condval_12 != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_13; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_13 = 1; + } else { + condval_13 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_13); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_47; + result_47.type_index = kTVMFFINone; + result_47.zero_padding = 0; + result_47.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_47) != 0) { + return -1; + } + } + int32_t condval_14; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_14 = 1; + } else { + condval_14 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[0]); + } + if ((condval_14 != 16384) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_48; + result_48.type_index = kTVMFFINone; + result_48.zero_padding = 0; + result_48.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_48) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)residual)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_49; + result_49.type_index = kTVMFFINone; + result_49.zero_padding = 0; + result_49.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_49) != 0) { + return -1; + } + } + if ((((DLTensor*)residual)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)residual)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_50; + result_50.type_index = kTVMFFINone; + result_50.zero_padding = 0; + result_50.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_50) != 0) { + return -1; + } + } + if ((((DLTensor*)residual)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_51; + result_51.type_index = kTVMFFINone; + result_51.zero_padding = 0; + result_51.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_51) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (residual_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_52; + result_52.type_index = kTVMFFINone; + result_52.zero_padding = 0; + result_52.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_52) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)post_mix)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)post_mix)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)post_mix)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_53; + result_53.type_index = kTVMFFINone; + result_53.zero_padding = 0; + result_53.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_53) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_54; + result_54.type_index = kTVMFFINone; + result_54.zero_padding = 0; + result_54.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_54) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[1]) != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_55; + result_55.type_index = kTVMFFINone; + result_55.zero_padding = 0; + result_55.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_55) != 0) { + return -1; + } + } + int32_t condval_15; + if ((mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides == NULL)) { + condval_15 = 1; + } else { + condval_15 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides)[1]); + } + if (condval_15 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_16; + if ((mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides == NULL)) { + condval_16 = 1; + } else { + condval_16 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_16); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_56; + result_56.type_index = kTVMFFINone; + result_56.zero_padding = 0; + result_56.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_56) != 0) { + return -1; + } + } + int32_t condval_17; + if ((mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides == NULL)) { + condval_17 = 1; + } else { + condval_17 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides)[0]); + } + if ((condval_17 != 4) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_57; + result_57.type_index = kTVMFFINone; + result_57.zero_padding = 0; + result_57.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_57) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)post_mix)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_58; + result_58.type_index = kTVMFFINone; + result_58.zero_padding = 0; + result_58.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_58) != 0) { + return -1; + } + } + if ((((DLTensor*)post_mix)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_59; + result_59.type_index = kTVMFFINone; + result_59.zero_padding = 0; + result_59.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_59) != 0) { + return -1; + } + } + if ((((DLTensor*)post_mix)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_60; + result_60.type_index = kTVMFFINone; + result_60.zero_padding = 0; + result_60.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_60) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (post_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_61; + result_61.type_index = kTVMFFINone; + result_61.zero_padding = 0; + result_61.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_61) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)comb_mix)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)comb_mix)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)comb_mix)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_62; + result_62.type_index = kTVMFFINone; + result_62.zero_padding = 0; + result_62.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_62) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_63; + result_63.type_index = kTVMFFINone; + result_63.zero_padding = 0; + result_63.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_63) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[1]) != 16) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_64; + result_64.type_index = kTVMFFINone; + result_64.zero_padding = 0; + result_64.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_64) != 0) { + return -1; + } + } + int32_t condval_18; + if ((mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides == NULL)) { + condval_18 = 1; + } else { + condval_18 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides)[1]); + } + if (condval_18 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_19; + if ((mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides == NULL)) { + condval_19 = 1; + } else { + condval_19 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_19); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_65; + result_65.type_index = kTVMFFINone; + result_65.zero_padding = 0; + result_65.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_65) != 0) { + return -1; + } + } + int32_t condval_20; + if ((mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides == NULL)) { + condval_20 = 1; + } else { + condval_20 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides)[0]); + } + if ((condval_20 != 16) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_66; + result_66.type_index = kTVMFFINone; + result_66.zero_padding = 0; + result_66.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_66) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)comb_mix)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_67; + result_67.type_index = kTVMFFINone; + result_67.zero_padding = 0; + result_67.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_67) != 0) { + return -1; + } + } + if ((((DLTensor*)comb_mix)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_68; + result_68.type_index = kTVMFFINone; + result_68.zero_padding = 0; + result_68.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_68) != 0) { + return -1; + } + } + if ((((DLTensor*)comb_mix)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_69; + result_69.type_index = kTVMFFINone; + result_69.zero_padding = 0; + result_69.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_69) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (comb_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_70; + result_70.type_index = kTVMFFINone; + result_70.zero_padding = 0; + result_70.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_70) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)layer_input)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)layer_input)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)layer_input)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_71; + result_71.type_index = kTVMFFINone; + result_71.zero_padding = 0; + result_71.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_71) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_72; + result_72.type_index = kTVMFFINone; + result_72.zero_padding = 0; + result_72.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_72) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[1]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_73; + result_73.type_index = kTVMFFINone; + result_73.zero_padding = 0; + result_73.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_73) != 0) { + return -1; + } + } + int32_t condval_21; + if ((mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides == NULL)) { + condval_21 = 1; + } else { + condval_21 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides)[1]); + } + if (condval_21 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_22; + if ((mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides == NULL)) { + condval_22 = 1; + } else { + condval_22 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_22); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_74; + result_74.type_index = kTVMFFINone; + result_74.zero_padding = 0; + result_74.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_74) != 0) { + return -1; + } + } + int32_t condval_23; + if ((mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides == NULL)) { + condval_23 = 1; + } else { + condval_23 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides)[0]); + } + if ((condval_23 != 4096) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_75; + result_75.type_index = kTVMFFINone; + result_75.zero_padding = 0; + result_75.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_75) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)layer_input)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_76; + result_76.type_index = kTVMFFINone; + result_76.zero_padding = 0; + result_76.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_76) != 0) { + return -1; + } + } + if ((((DLTensor*)layer_input)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_77; + result_77.type_index = kTVMFFINone; + result_77.zero_padding = 0; + result_77.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_77) != 0) { + return -1; + } + } + if ((((DLTensor*)layer_input)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_78; + result_78.type_index = kTVMFFINone; + result_78.zero_padding = 0; + result_78.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_78) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (layer_input_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_79; + result_79.type_index = kTVMFFINone; + result_79.zero_padding = 0; + result_79.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_79) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)norm_weight)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)norm_weight)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)norm_weight)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_80; + result_80.type_index = kTVMFFINone; + result_80.zero_padding = 0; + result_80.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_80) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_shape)[0]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_81; + result_81.type_index = kTVMFFINone; + result_81.zero_padding = 0; + result_81.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_81) != 0) { + return -1; + } + } + int32_t condval_24; + if ((mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides == NULL)) { + condval_24 = 1; + } else { + condval_24 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides)[0]); + } + if (condval_24 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_25; + if ((mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides == NULL)) { + condval_25 = 1; + } else { + condval_25 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides)[0]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_25); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_82; + result_82.type_index = kTVMFFINone; + result_82.zero_padding = 0; + result_82.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_82) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)norm_weight)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_83; + result_83.type_index = kTVMFFINone; + result_83.zero_padding = 0; + result_83.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_83) != 0) { + return -1; + } + } + if ((((DLTensor*)norm_weight)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_84; + result_84.type_index = kTVMFFINone; + result_84.zero_padding = 0; + result_84.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_84) != 0) { + return -1; + } + } + if ((((DLTensor*)norm_weight)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_85; + result_85.type_index = kTVMFFINone; + result_85.zero_padding = 0; + result_85.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_85) != 0) { + return -1; + } + } + if (norm_weight_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_86; + result_86.type_index = kTVMFFINone; + result_86.zero_padding = 0; + result_86.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_86) != 0) { + return -1; + } + } + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = ((int64_t)2); + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = ((int64_t)dev_id); + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + if (__tvm_set_device_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_set_device", &__tvm_set_device_packed) != 0) { + return -1; + } + } + TVMFFIAny result_87; + result_87.type_index = kTVMFFINone; + result_87.zero_padding = 0; + result_87.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_set_device_packed, (TVMFFIAny*) stack_ffi_any, 2, &result_87) != 0) { + return -1; + } + if (comb_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = comb_mix_1; + if (gemm_out_mul_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = gemm_out_mul_1; + if (gemm_out_sqrsum_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = gemm_out_sqrsum_1; + if (hc_base_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_ptr) = hc_base_1; + if (hc_scale_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_ptr) = hc_scale_1; + if (layer_input_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_ptr) = layer_input_1; + if (norm_weight_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_ptr) = norm_weight_1; + if (post_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_ptr) = post_mix_1; + if (residual_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_ptr) = residual_1; + (((TVMFFIAny*)stack_ffi_any)[9].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[9].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[9].v_int64) = ((int64_t)num_tokens); + (((TVMFFIAny*)stack_ffi_any)[10].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[10].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[10].v_int64) = ((int64_t)num_tokens); + (((TVMFFIAny*)stack_ffi_any)[11].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[11].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[11].v_int64) = ((int64_t)96); + (((TVMFFIAny*)stack_ffi_any)[12].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[12].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[12].v_int64) = ((int64_t)1); + (((TVMFFIAny*)stack_ffi_any)[13].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[13].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[13].v_int64) = ((int64_t)1); + (((TVMFFIAny*)stack_ffi_any)[14].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[14].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[14].v_int64) = ((int64_t)29040); + (((TVMFFIAny*)stack_ffi_any)[15].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[15].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[15].v_int64) = (int64_t)0; + if (mhc_pre_big_fuse_with_norm_tilelang_kernel_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "mhc_pre_big_fuse_with_norm_tilelang_kernel", &mhc_pre_big_fuse_with_norm_tilelang_kernel_packed) != 0) { + return -1; + } + } + TVMFFIAny result_88; + result_88.type_index = kTVMFFINone; + result_88.zero_padding = 0; + result_88.v_int64 = 0; + if (TVMFFIFunctionCall(mhc_pre_big_fuse_with_norm_tilelang_kernel_packed, (TVMFFIAny*) stack_ffi_any, 15, &result_88) != 0) { + return -1; + } + return 0; +} + +// CodegenC: NOTE: Auto-generated entry function +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_main(void* self, void* args,int num_args, void* result) { + return __tvm_ffi_mhc_pre_big_fuse_with_norm_tilelang(self, args, num_args, result); +} diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/34141341ae4687b7d5cb99f48bcdb971fae6efe8bba5eed695620f0e86b8bdd4/params.pkl b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/34141341ae4687b7d5cb99f48bcdb971fae6efe8bba5eed695620f0e86b8bdd4/params.pkl new file mode 100644 index 0000000..d01ecff Binary files /dev/null and b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/34141341ae4687b7d5cb99f48bcdb971fae6efe8bba5eed695620f0e86b8bdd4/params.pkl differ diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/455ef1b63b3a592f4741c938fcfb8d01f90e8269880307cffbf4438ed668de0b/device_kernel.cu b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/455ef1b63b3a592f4741c938fcfb8d01f90e8269880307cffbf4438ed668de0b/device_kernel.cu new file mode 100644 index 0000000..4813cbe --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/455ef1b63b3a592f4741c938fcfb8d01f90e8269880307cffbf4438ed668de0b/device_kernel.cu @@ -0,0 +1,424 @@ +#include +#include +#include +#include +#include +#include +#include +#ifdef ENABLE_BF16 +#include +#endif + +extern "C" __global__ void mhc_pre_big_fuse_with_norm_tilelang_kernel(float* comb_mix, const float* gemm_out_mul, const float* gemm_out_sqrsum, const float* hc_base, const float* hc_scale, bfloat16_t* layer_input, const bfloat16_t* norm_weight, float* post_mix, const bfloat16_t* residual, int num_tokens); +extern "C" __global__ void __launch_bounds__(96, 1) mhc_pre_big_fuse_with_norm_tilelang_kernel(float* comb_mix, const float* gemm_out_mul, const float* gemm_out_sqrsum, const float* hc_base, const float* hc_scale, bfloat16_t* layer_input, const bfloat16_t* norm_weight, float* post_mix, const bfloat16_t* residual, int num_tokens) { + extern __shared__ __align__(1024) uchar buf_dyn_shmem[]; + float mixes[1]; + float rms[1]; + float cm[1]; + float row_max[1]; + float row_sum[1]; + float col_sum[1]; + float sumsq_per_pos[16]; + float sumsq[1]; + float rsqrt_norm[1]; + float xl[64]; + float ol[16]; + bfloat16_t xs_local_cast[8]; + bfloat16_t xs_local_cast_1[8]; + bfloat16_t xs_local_cast_2[8]; + float w_local[16]; + float ol_1[16]; + bfloat16_t w_shared_local_cast_3[8]; + bfloat16_t output_shared_local_cast_4[8]; + bfloat16_t layer_input_local_cast_5[8]; + bfloat16_t w_shared_local_cast_6[8]; + bfloat16_t output_shared_local_cast_7[8]; + bfloat16_t layer_input_local_cast_8[8]; + bfloat16_t w_shared_local_cast_9[8]; + bfloat16_t output_shared_local_cast_10[8]; + bfloat16_t layer_input_local_cast_11[8]; + mixes[0] = 0x0p+0f/*0.000000e+00*/; + rms[0] = 0x0p+0f/*0.000000e+00*/; + cudaGridDependencySynchronize(); + for (int i_split = 0; i_split < 8; ++i_split) { + rms[0] = (rms[0] + gemm_out_sqrsum[((((int64_t)i_split) * ((int64_t)num_tokens)) + ((int64_t)((int)blockIdx.x)))]); + } + rms[0] = rsqrtf(((rms[0] / 0x1p+14f/*1.638400e+04*/) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + mixes[0] = 0x0p+0f/*0.000000e+00*/; + for (int i_split_1 = 0; i_split_1 < 8; ++i_split_1) { + mixes[0] = (mixes[0] + gemm_out_mul[(((((int64_t)((int)blockIdx.x)) * (int64_t)24) + ((((int64_t)i_split_1) * ((int64_t)num_tokens)) * (int64_t)24)) + (((int64_t)((int)threadIdx.x)) % (int64_t)24))]); + } + mixes[0] = (mixes[0] * rms[0]); + if ((((int)threadIdx.x) / 24) == 0) { + ((float*)buf_dyn_shmem)[(((int)threadIdx.x) % 24)] = mixes[0]; + } + __syncthreads(); + if (((int)threadIdx.x) < 32) { + if (((int)threadIdx.x) < 4) { + post_mix[((((int64_t)((int)blockIdx.x)) * (int64_t)4) + ((int64_t)((int)threadIdx.x)))] = ((0x1p+0f/*1.000000e+00*/ / (0x1p+0f/*1.000000e+00*/ + expf((0x0p+0f/*0.000000e+00*/ - ((((float*)buf_dyn_shmem)[(((int)threadIdx.x) + 4)] * hc_scale[1]) + hc_base[(((int)threadIdx.x) + 4)]))))) * 0x1p+1f/*2.000000e+00*/); + } + cm[0] = ((((float*)buf_dyn_shmem)[((((int)threadIdx.x) & 15) + 8)] * hc_scale[2]) + hc_base[((((int)threadIdx.x) & 15) + 8)]); + row_max[0] = -CUDART_INF_F; + row_max[0] = max(row_max[0], cm[0]); + row_max[0] = tl::AllReduce>::run(row_max[0]); + cm[0] = expf((cm[0] - row_max[0])); + row_sum[0] = 0x0p+0f/*0.000000e+00*/; + row_sum[0] = (row_sum[0] + cm[0]); + row_sum[0] = tl::AllReduce>::run(row_sum[0]); + cm[0] = ((cm[0] / row_sum[0]) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/); + col_sum[0] = 0x0p+0f/*0.000000e+00*/; + col_sum[0] = (col_sum[0] + cm[0]); + col_sum[0] = tl::AllReduce>::run(col_sum[0]); + cm[0] = (cm[0] / (col_sum[0] + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + for (int __1 = 0; __1 < 19; ++__1) { + row_sum[0] = 0x0p+0f/*0.000000e+00*/; + row_sum[0] = (row_sum[0] + cm[0]); + row_sum[0] = tl::AllReduce>::run(row_sum[0]); + cm[0] = (cm[0] / (row_sum[0] + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + col_sum[0] = 0x0p+0f/*0.000000e+00*/; + col_sum[0] = (col_sum[0] + cm[0]); + col_sum[0] = tl::AllReduce>::run(col_sum[0]); + cm[0] = (cm[0] / (col_sum[0] + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + } + if ((((int)threadIdx.x) >> 4) == 0) { + comb_mix[((((int64_t)((int)blockIdx.x)) * (int64_t)16) + (((int64_t)((int)threadIdx.x)) & (int64_t)15))] = cm[0]; + } + } else { + if (((int)threadIdx.x) < 36) { + ((float*)buf_dyn_shmem)[(((int)threadIdx.x) + 7224)] = ((0x1p+0f/*1.000000e+00*/ / (0x1p+0f/*1.000000e+00*/ + expf((0x0p+0f/*0.000000e+00*/ - ((((float*)buf_dyn_shmem)[(((int)threadIdx.x) - 32)] * hc_scale[0]) + hc_base[(((int)threadIdx.x) - 32)]))))) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/); + } + #pragma unroll + for (int i = 0; i < 4; ++i) { + float broadcast_var = 0x0p+0f/*0.000000e+00*/; + *(float4*)(sumsq_per_pos + (i * 4)) = make_float4(broadcast_var, broadcast_var, broadcast_var, broadcast_var); + } + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_1 = 0; i_1 < 8; ++i_1) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i_1 >> 1) * 1024) + (((((i_1 * 64) + ((int)threadIdx.x)) + 96) & 127) * 8)) + 48)])), (&(residual[(((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + ((((int64_t)i_1) >> (int64_t)1) * (int64_t)4096)) + (((((((int64_t)i_1) * (int64_t)64) + ((int64_t)((int)threadIdx.x))) + (int64_t)96) & (int64_t)127) * (int64_t)8))]))); + } + tl::cp_async_commit(); + #pragma unroll + for (int i_2 = 0; i_2 < 8; ++i_2) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i_2 >> 1) * 1024) + (((((i_2 * 64) + ((int)threadIdx.x)) + 96) & 127) * 8)) + 4144)])), (&(residual[((((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + ((((int64_t)i_2) >> (int64_t)1) * (int64_t)4096)) + (((((((int64_t)i_2) * (int64_t)64) + ((int64_t)((int)threadIdx.x))) + (int64_t)96) & (int64_t)127) * (int64_t)8)) + (int64_t)1024)]))); + } + tl::cp_async_commit(); + for (int i0_h = 0; i0_h < 2; ++i0_h) { + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_3 = 0; i_3 < 8; ++i_3) { + *(uint4*)(xs_local_cast + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + ((((i0_h * 4096) + (i_3 * 512)) + (((int)threadIdx.x) * 8)) - 208)); + for (int vec = 0; vec < 2; ++vec) { + float4 __2; + uint2 v_ = *(uint2*)(xs_local_cast + (vec * 4)); + ((float2*)(&__2))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v_))[0]); + ((float2*)(&__2))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v_))[1]); + *(float4*)(xl + ((i_3 * 8) + (vec * 4))) = __2; + } + } + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_4 = 0; i_4 < 8; ++i_4) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i0_h * 4096) + ((i_4 >> 1) * 1024)) + (((((i_4 * 64) + ((int)threadIdx.x)) + 96) & 127) * 8)) + 48)])), (&(residual[(((((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + ((((int64_t)i_4) >> (int64_t)1) * (int64_t)4096)) + (((int64_t)i0_h) * (int64_t)1024)) + (((((((int64_t)i_4) * (int64_t)64) + ((int64_t)((int)threadIdx.x))) + (int64_t)96) & (int64_t)127) * (int64_t)8)) + (int64_t)2048)]))); + } + tl::cp_async_commit(); + #pragma unroll + for (int i_5 = 0; i_5 < 4; ++i_5) { + float broadcast_var_1 = 0x0p+0f/*0.000000e+00*/; + *(float4*)(ol + (i_5 * 4)) = make_float4(broadcast_var_1, broadcast_var_1, broadcast_var_1, broadcast_var_1); + } + tl::__sync_thread_partial<3, 64>(); + for (int i_hc = 0; i_hc < 4; ++i_hc) { + float pre = ((float*)buf_dyn_shmem)[(i_hc + 7256)]; + #pragma unroll + for (int i_6 = 0; i_6 < 16; ++i_6) { + ol[i_6] = (ol[i_6] + (pre * xl[((i_hc * 16) + i_6)])); + } + } + #pragma unroll + for (int i_7 = 0; i_7 < 4; ++i_7) { + float4 __3; + float4 v__1 = *(float4*)(sumsq_per_pos + (i_7 * 4)); + float4 __4; + float4 v__2 = *(float4*)(ol + (i_7 * 4)); + __4.x = (v__2.x*v__2.x); + __4.y = (v__2.y*v__2.y); + __4.z = (v__2.z*v__2.z); + __4.w = (v__2.w*v__2.w); + __3.x = (v__1.x+__4.x); + __3.y = (v__1.y+__4.y); + __3.z = (v__1.z+__4.z); + __3.w = (v__1.w+__4.w); + *(float4*)(sumsq_per_pos + (i_7 * 4)) = __3; + uint2 __5; + float4 v__3 = *(float4*)(ol + (i_7 * 4)); + (reinterpret_cast<__nv_bfloat162*>(&__5))[0] = __float22bfloat162_rn(((float2*)(&v__3))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__5))[1] = __float22bfloat162_rn(((float2*)(&v__3))[1]); + *(uint2*)(((bfloat16_t*)buf_dyn_shmem) + (((((i0_h * 1024) + ((i_7 >> 1) * 512)) + (((int)threadIdx.x) * 8)) + ((i_7 & 1) * 4)) + 7984)) = __5; + } + } + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_8 = 0; i_8 < 8; ++i_8) { + *(uint4*)(xs_local_cast_1 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_8 * 512) + (((int)threadIdx.x) * 8)) - 208)); + for (int vec_1 = 0; vec_1 < 2; ++vec_1) { + float4 __6; + uint2 v__4 = *(uint2*)(xs_local_cast_1 + (vec_1 * 4)); + ((float2*)(&__6))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__4))[0]); + ((float2*)(&__6))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__4))[1]); + *(float4*)(xl + ((i_8 * 8) + (vec_1 * 4))) = __6; + } + } + #pragma unroll + for (int i_9 = 0; i_9 < 4; ++i_9) { + float broadcast_var_2 = 0x0p+0f/*0.000000e+00*/; + *(float4*)(ol + (i_9 * 4)) = make_float4(broadcast_var_2, broadcast_var_2, broadcast_var_2, broadcast_var_2); + } + for (int i_hc_1 = 0; i_hc_1 < 4; ++i_hc_1) { + float pre_1 = ((float*)buf_dyn_shmem)[(i_hc_1 + 7256)]; + #pragma unroll + for (int i_10 = 0; i_10 < 16; ++i_10) { + ol[i_10] = (ol[i_10] + (pre_1 * xl[((i_hc_1 * 16) + i_10)])); + } + } + #pragma unroll + for (int i_11 = 0; i_11 < 4; ++i_11) { + float4 __7; + float4 v__5 = *(float4*)(sumsq_per_pos + (i_11 * 4)); + float4 __8; + float4 v__6 = *(float4*)(ol + (i_11 * 4)); + __8.x = (v__6.x*v__6.x); + __8.y = (v__6.y*v__6.y); + __8.z = (v__6.z*v__6.z); + __8.w = (v__6.w*v__6.w); + __7.x = (v__5.x+__8.x); + __7.y = (v__5.y+__8.y); + __7.z = (v__5.z+__8.z); + __7.w = (v__5.w+__8.w); + *(float4*)(sumsq_per_pos + (i_11 * 4)) = __7; + uint2 __9; + float4 v__7 = *(float4*)(ol + (i_11 * 4)); + (reinterpret_cast<__nv_bfloat162*>(&__9))[0] = __float22bfloat162_rn(((float2*)(&v__7))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__9))[1] = __float22bfloat162_rn(((float2*)(&v__7))[1]); + *(uint2*)(((bfloat16_t*)buf_dyn_shmem) + (((((i_11 >> 1) * 512) + (((int)threadIdx.x) * 8)) + ((i_11 & 1) * 4)) + 10032)) = __9; + } + tl::cp_async_wait<0>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_12 = 0; i_12 < 8; ++i_12) { + *(uint4*)(xs_local_cast_2 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_12 * 512) + (((int)threadIdx.x) * 8)) + 3888)); + for (int vec_2 = 0; vec_2 < 2; ++vec_2) { + float4 __10; + uint2 v__8 = *(uint2*)(xs_local_cast_2 + (vec_2 * 4)); + ((float2*)(&__10))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__8))[0]); + ((float2*)(&__10))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__8))[1]); + *(float4*)(xl + ((i_12 * 8) + (vec_2 * 4))) = __10; + } + } + #pragma unroll + for (int i_13 = 0; i_13 < 4; ++i_13) { + float broadcast_var_3 = 0x0p+0f/*0.000000e+00*/; + *(float4*)(ol + (i_13 * 4)) = make_float4(broadcast_var_3, broadcast_var_3, broadcast_var_3, broadcast_var_3); + } + for (int i_hc_2 = 0; i_hc_2 < 4; ++i_hc_2) { + float pre_2 = ((float*)buf_dyn_shmem)[(i_hc_2 + 7256)]; + #pragma unroll + for (int i_14 = 0; i_14 < 16; ++i_14) { + ol[i_14] = (ol[i_14] + (pre_2 * xl[((i_hc_2 * 16) + i_14)])); + } + } + #pragma unroll + for (int i_15 = 0; i_15 < 4; ++i_15) { + float4 __11; + float4 v__9 = *(float4*)(sumsq_per_pos + (i_15 * 4)); + float4 __12; + float4 v__10 = *(float4*)(ol + (i_15 * 4)); + __12.x = (v__10.x*v__10.x); + __12.y = (v__10.y*v__10.y); + __12.z = (v__10.z*v__10.z); + __12.w = (v__10.w*v__10.w); + __11.x = (v__9.x+__12.x); + __11.y = (v__9.y+__12.y); + __11.z = (v__9.z+__12.z); + __11.w = (v__9.w+__12.w); + *(float4*)(sumsq_per_pos + (i_15 * 4)) = __11; + uint2 __13; + float4 v__11 = *(float4*)(ol + (i_15 * 4)); + (reinterpret_cast<__nv_bfloat162*>(&__13))[0] = __float22bfloat162_rn(((float2*)(&v__11))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__13))[1] = __float22bfloat162_rn(((float2*)(&v__11))[1]); + *(uint2*)(((bfloat16_t*)buf_dyn_shmem) + (((((i_15 >> 1) * 512) + (((int)threadIdx.x) * 8)) + ((i_15 & 1) * 4)) + 11056)) = __13; + } + sumsq[0] = 0x0p+0f/*0.000000e+00*/; + #pragma unroll + for (int rv = 0; rv < 16; ++rv) { + sumsq[0] = (sumsq[0] + sumsq_per_pos[(((rv & 1) * 8) + (rv >> 1))]); + } + tl::__sync_thread_partial<3, 64>(); + sumsq[0] = tl::AllReduce>::run(sumsq[0], (&(((float*)buf_dyn_shmem)[7192]))); + rsqrt_norm[0] = rsqrtf(((sumsq[0] / 0x1p+12f/*4.096000e+03*/) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + #pragma unroll + for (int i_16 = 0; i_16 < 2; ++i_16) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[(((i_16 * 512) + (((int)threadIdx.x) * 8)) + 12080)])), (&(norm_weight[(((i_16 * 512) + (((int)threadIdx.x) * 8)) - 256)]))); + } + tl::cp_async_commit(); + #pragma unroll + for (int i_17 = 0; i_17 < 2; ++i_17) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[(((i_17 * 512) + (((int)threadIdx.x) * 8)) + 13104)])), (&(norm_weight[(((i_17 * 512) + (((int)threadIdx.x) * 8)) + 768)]))); + } + tl::cp_async_commit(); + for (int i0_h_1 = 0; i0_h_1 < 2; ++i0_h_1) { + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_18 = 0; i_18 < 2; ++i_18) { + *(uint4*)(w_shared_local_cast_3 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + ((((i0_h_1 * 1024) + (i_18 * 512)) + (((int)threadIdx.x) * 8)) + 12080)); + for (int vec_3 = 0; vec_3 < 2; ++vec_3) { + float4 __14; + uint2 v__12 = *(uint2*)(w_shared_local_cast_3 + (vec_3 * 4)); + ((float2*)(&__14))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__12))[0]); + ((float2*)(&__14))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__12))[1]); + *(float4*)(w_local + ((i_18 * 8) + (vec_3 * 4))) = __14; + } + } + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_19 = 0; i_19 < 2; ++i_19) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i0_h_1 * 1024) + (i_19 * 512)) + (((int)threadIdx.x) * 8)) + 12080)])), (&(norm_weight[((((i0_h_1 * 1024) + (i_19 * 512)) + (((int)threadIdx.x) * 8)) + 1792)]))); + } + tl::cp_async_commit(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_20 = 0; i_20 < 2; ++i_20) { + *(uint4*)(output_shared_local_cast_4 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + ((((i0_h_1 * 1024) + (i_20 * 512)) + (((int)threadIdx.x) * 8)) + 7984)); + for (int vec_4 = 0; vec_4 < 2; ++vec_4) { + float4 __15; + float4 __16; + float4 __17; + uint2 v__13 = *(uint2*)(output_shared_local_cast_4 + (vec_4 * 4)); + ((float2*)(&__17))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__13))[0]); + ((float2*)(&__17))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__13))[1]); + float4 v__14 = make_float4(rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0]); + __16.x = (__17.x*v__14.x); + __16.y = (__17.y*v__14.y); + __16.z = (__17.z*v__14.z); + __16.w = (__17.w*v__14.w); + float4 v__15 = *(float4*)(w_local + ((i_20 * 8) + (vec_4 * 4))); + __15.x = (__16.x*v__15.x); + __15.y = (__16.y*v__15.y); + __15.z = (__16.z*v__15.z); + __15.w = (__16.w*v__15.w); + *(float4*)(ol_1 + ((i_20 * 8) + (vec_4 * 4))) = __15; + } + } + #pragma unroll + for (int i_21 = 0; i_21 < 2; ++i_21) { + for (int vec_5 = 0; vec_5 < 2; ++vec_5) { + uint2 __18; + float4 v__16 = *(float4*)(ol_1 + ((i_21 * 8) + (vec_5 * 4))); + (reinterpret_cast<__nv_bfloat162*>(&__18))[0] = __float22bfloat162_rn(((float2*)(&v__16))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__18))[1] = __float22bfloat162_rn(((float2*)(&v__16))[1]); + *(uint2*)(layer_input_local_cast_5 + (vec_5 * 4)) = __18; + } + *(uint4*)(layer_input + (((((((int64_t)((int)blockIdx.x)) * (int64_t)4096) + (((int64_t)i0_h_1) * (int64_t)1024)) + (((int64_t)i_21) * (int64_t)512)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8)) - (int64_t)256)) = *(uint4*)(layer_input_local_cast_5 + 0); + } + } + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_22 = 0; i_22 < 2; ++i_22) { + *(uint4*)(w_shared_local_cast_6 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_22 * 512) + (((int)threadIdx.x) * 8)) + 12080)); + for (int vec_6 = 0; vec_6 < 2; ++vec_6) { + float4 __19; + uint2 v__17 = *(uint2*)(w_shared_local_cast_6 + (vec_6 * 4)); + ((float2*)(&__19))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__17))[0]); + ((float2*)(&__19))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__17))[1]); + *(float4*)(w_local + ((i_22 * 8) + (vec_6 * 4))) = __19; + } + } + #pragma unroll + for (int i_23 = 0; i_23 < 2; ++i_23) { + *(uint4*)(output_shared_local_cast_7 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_23 * 512) + (((int)threadIdx.x) * 8)) + 10032)); + for (int vec_7 = 0; vec_7 < 2; ++vec_7) { + float4 __20; + float4 __21; + float4 __22; + uint2 v__18 = *(uint2*)(output_shared_local_cast_7 + (vec_7 * 4)); + ((float2*)(&__22))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__18))[0]); + ((float2*)(&__22))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__18))[1]); + float4 v__19 = make_float4(rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0]); + __21.x = (__22.x*v__19.x); + __21.y = (__22.y*v__19.y); + __21.z = (__22.z*v__19.z); + __21.w = (__22.w*v__19.w); + float4 v__20 = *(float4*)(w_local + ((i_23 * 8) + (vec_7 * 4))); + __20.x = (__21.x*v__20.x); + __20.y = (__21.y*v__20.y); + __20.z = (__21.z*v__20.z); + __20.w = (__21.w*v__20.w); + *(float4*)(ol_1 + ((i_23 * 8) + (vec_7 * 4))) = __20; + } + } + #pragma unroll + for (int i_24 = 0; i_24 < 2; ++i_24) { + for (int vec_8 = 0; vec_8 < 2; ++vec_8) { + uint2 __23; + float4 v__21 = *(float4*)(ol_1 + ((i_24 * 8) + (vec_8 * 4))); + (reinterpret_cast<__nv_bfloat162*>(&__23))[0] = __float22bfloat162_rn(((float2*)(&v__21))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__23))[1] = __float22bfloat162_rn(((float2*)(&v__21))[1]); + *(uint2*)(layer_input_local_cast_8 + (vec_8 * 4)) = __23; + } + *(uint4*)(layer_input + ((((((int64_t)((int)blockIdx.x)) * (int64_t)4096) + (((int64_t)i_24) * (int64_t)512)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8)) + (int64_t)1792)) = *(uint4*)(layer_input_local_cast_8 + 0); + } + tl::cp_async_wait<0>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_25 = 0; i_25 < 2; ++i_25) { + *(uint4*)(w_shared_local_cast_9 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_25 * 512) + (((int)threadIdx.x) * 8)) + 13104)); + for (int vec_9 = 0; vec_9 < 2; ++vec_9) { + float4 __24; + uint2 v__22 = *(uint2*)(w_shared_local_cast_9 + (vec_9 * 4)); + ((float2*)(&__24))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__22))[0]); + ((float2*)(&__24))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__22))[1]); + *(float4*)(w_local + ((i_25 * 8) + (vec_9 * 4))) = __24; + } + } + #pragma unroll + for (int i_26 = 0; i_26 < 2; ++i_26) { + *(uint4*)(output_shared_local_cast_10 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_26 * 512) + (((int)threadIdx.x) * 8)) + 11056)); + for (int vec_10 = 0; vec_10 < 2; ++vec_10) { + float4 __25; + float4 __26; + float4 __27; + uint2 v__23 = *(uint2*)(output_shared_local_cast_10 + (vec_10 * 4)); + ((float2*)(&__27))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__23))[0]); + ((float2*)(&__27))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__23))[1]); + float4 v__24 = make_float4(rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0]); + __26.x = (__27.x*v__24.x); + __26.y = (__27.y*v__24.y); + __26.z = (__27.z*v__24.z); + __26.w = (__27.w*v__24.w); + float4 v__25 = *(float4*)(w_local + ((i_26 * 8) + (vec_10 * 4))); + __25.x = (__26.x*v__25.x); + __25.y = (__26.y*v__25.y); + __25.z = (__26.z*v__25.z); + __25.w = (__26.w*v__25.w); + *(float4*)(ol_1 + ((i_26 * 8) + (vec_10 * 4))) = __25; + } + } + #pragma unroll + for (int i_27 = 0; i_27 < 2; ++i_27) { + for (int vec_11 = 0; vec_11 < 2; ++vec_11) { + uint2 __28; + float4 v__26 = *(float4*)(ol_1 + ((i_27 * 8) + (vec_11 * 4))); + (reinterpret_cast<__nv_bfloat162*>(&__28))[0] = __float22bfloat162_rn(((float2*)(&v__26))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__28))[1] = __float22bfloat162_rn(((float2*)(&v__26))[1]); + *(uint2*)(layer_input_local_cast_11 + (vec_11 * 4)) = __28; + } + *(uint4*)(layer_input + ((((((int64_t)((int)blockIdx.x)) * (int64_t)4096) + (((int64_t)i_27) * (int64_t)512)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8)) + (int64_t)2816)) = *(uint4*)(layer_input_local_cast_11 + 0); + } + } + cudaTriggerProgrammaticLaunchCompletion(); +} + diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/455ef1b63b3a592f4741c938fcfb8d01f90e8269880307cffbf4438ed668de0b/host_kernel.cu b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/455ef1b63b3a592f4741c938fcfb8d01f90e8269880307cffbf4438ed668de0b/host_kernel.cu new file mode 100644 index 0000000..ac65b4a --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/455ef1b63b3a592f4741c938fcfb8d01f90e8269880307cffbf4438ed668de0b/host_kernel.cu @@ -0,0 +1,3359 @@ +// tilelang target: c -keys=cpu +#define TVM_EXPORTS +#include "tvm/runtime/base.h" +#include "tvm/runtime/c_backend_api.h" +#include "tvm/ffi/c_api.h" +#include +#include +#include +#ifdef __OBJC__ +#include "tvm/runtime/device_api.h" +#include "tvm/ffi/function.h" +#include +#include +#include +#endif +void* __tvm_ffi__library_ctx = NULL; +static void* __tvm_error_ndim_mismatch_packed = NULL; +static void* __tvm_error_dtype_mismatch_packed = NULL; +static void* __tvm_error_expect_eq_packed = NULL; +static void* __tvm_error_constraint_violation_packed = NULL; +static void* __tvm_error_byte_offset_mismatch_packed = NULL; +static void* __tvm_error_device_type_mismatch_packed = NULL; +static void* __tvm_error_null_ptr_packed = NULL; +static void* __tvm_set_device_packed = NULL; +static void* mhc_pre_big_fuse_with_norm_tilelang_kernel_packed = NULL; +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_mhc_pre_big_fuse_with_norm_tilelang(void* self_handle, void* args, int32_t num_args, void* result); +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_mhc_pre_big_fuse_with_norm_tilelang(void* self_handle, void* args, int32_t num_args, void* result) { + __attribute__((aligned(64))) TVMFFIAny stack[16]; + void* stack_ffi_any = stack; + if (!((num_args == 9))) { + char __tvm_assert_msg_buf[512]; + snprintf(__tvm_assert_msg_buf, 512, "%s; expected: %lld, got: %lld", "mhc_pre_big_fuse_with_norm_tilelang: num_args should be 9", (long long)(num_args), (long long)(9)); + TVMFFIErrorSetRaisedFromCStr("RuntimeError", __tvm_assert_msg_buf); + return -1; + } + if (!(!(args == NULL))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang: args pointer is NULL"); + return -1; + } + int32_t gemm_out_mul_type_index = (((TVMFFIAny*)args)[0].type_index); + if (!(((((gemm_out_mul_type_index == 0) || (gemm_out_mul_type_index == 4)) || (gemm_out_mul_type_index == 7)) || (64 <= gemm_out_mul_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input gemm_out_mul expected pointer or tensor handle"); + return -1; + } + int32_t gemm_out_sqrsum_type_index = (((TVMFFIAny*)args)[1].type_index); + if (!(((((gemm_out_sqrsum_type_index == 0) || (gemm_out_sqrsum_type_index == 4)) || (gemm_out_sqrsum_type_index == 7)) || (64 <= gemm_out_sqrsum_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input gemm_out_sqrsum expected pointer or tensor handle"); + return -1; + } + int32_t hc_scale_type_index = (((TVMFFIAny*)args)[2].type_index); + if (!(((((hc_scale_type_index == 0) || (hc_scale_type_index == 4)) || (hc_scale_type_index == 7)) || (64 <= hc_scale_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input hc_scale expected pointer or tensor handle"); + return -1; + } + int32_t hc_base_type_index = (((TVMFFIAny*)args)[3].type_index); + if (!(((((hc_base_type_index == 0) || (hc_base_type_index == 4)) || (hc_base_type_index == 7)) || (64 <= hc_base_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input hc_base expected pointer or tensor handle"); + return -1; + } + int32_t residual_type_index = (((TVMFFIAny*)args)[4].type_index); + if (!(((((residual_type_index == 0) || (residual_type_index == 4)) || (residual_type_index == 7)) || (64 <= residual_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input residual expected pointer or tensor handle"); + return -1; + } + int32_t post_mix_type_index = (((TVMFFIAny*)args)[5].type_index); + if (!(((((post_mix_type_index == 0) || (post_mix_type_index == 4)) || (post_mix_type_index == 7)) || (64 <= post_mix_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input post_mix expected pointer or tensor handle"); + return -1; + } + int32_t comb_mix_type_index = (((TVMFFIAny*)args)[6].type_index); + if (!(((((comb_mix_type_index == 0) || (comb_mix_type_index == 4)) || (comb_mix_type_index == 7)) || (64 <= comb_mix_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input comb_mix expected pointer or tensor handle"); + return -1; + } + int32_t layer_input_type_index = (((TVMFFIAny*)args)[7].type_index); + if (!(((((layer_input_type_index == 0) || (layer_input_type_index == 4)) || (layer_input_type_index == 7)) || (64 <= layer_input_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input layer_input expected pointer or tensor handle"); + return -1; + } + int32_t norm_weight_type_index = (((TVMFFIAny*)args)[8].type_index); + if (!(((((norm_weight_type_index == 0) || (norm_weight_type_index == 4)) || (norm_weight_type_index == 7)) || (64 <= norm_weight_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input norm_weight expected pointer or tensor handle"); + return -1; + } + void* gemm_out_mul = ((gemm_out_mul_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[0].v_ptr) + 24)) : (((TVMFFIAny*)args)[0].v_ptr)); + void* gemm_out_sqrsum = ((gemm_out_sqrsum_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[1].v_ptr) + 24)) : (((TVMFFIAny*)args)[1].v_ptr)); + void* hc_scale = ((hc_scale_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[2].v_ptr) + 24)) : (((TVMFFIAny*)args)[2].v_ptr)); + void* hc_base = ((hc_base_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[3].v_ptr) + 24)) : (((TVMFFIAny*)args)[3].v_ptr)); + void* residual = ((residual_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[4].v_ptr) + 24)) : (((TVMFFIAny*)args)[4].v_ptr)); + void* post_mix = ((post_mix_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[5].v_ptr) + 24)) : (((TVMFFIAny*)args)[5].v_ptr)); + void* comb_mix = ((comb_mix_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[6].v_ptr) + 24)) : (((TVMFFIAny*)args)[6].v_ptr)); + void* layer_input = ((layer_input_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[7].v_ptr) + 24)) : (((TVMFFIAny*)args)[7].v_ptr)); + void* norm_weight = ((norm_weight_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[8].v_ptr) + 24)) : (((TVMFFIAny*)args)[8].v_ptr)); + bool mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_is_null = (gemm_out_mul == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.gemm_out_mul is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_is_null = (gemm_out_sqrsum == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.gemm_out_sqrsum is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_hc_scale_is_null = (hc_scale == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_hc_scale_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.hc_scale is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_hc_base_is_null = (hc_base == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_hc_base_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.hc_base is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_residual_is_null = (residual == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_residual_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.residual is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_post_mix_is_null = (post_mix == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_post_mix_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.post_mix is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_comb_mix_is_null = (comb_mix == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_comb_mix_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.comb_mix is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_layer_input_is_null = (layer_input == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_layer_input_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.layer_input is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_norm_weight_is_null = (norm_weight == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_norm_weight_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.norm_weight is expected to have non-NULL pointer"); + return -1; + } + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape = (((DLTensor*)gemm_out_mul)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape = (((DLTensor*)gemm_out_sqrsum)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_hc_scale_shape = (((DLTensor*)hc_scale)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_hc_base_shape = (((DLTensor*)hc_base)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_residual_shape = (((DLTensor*)residual)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape = (((DLTensor*)post_mix)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape = (((DLTensor*)comb_mix)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape = (((DLTensor*)layer_input)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_norm_weight_shape = (((DLTensor*)norm_weight)[0].shape); + if ((((DLTensor*)gemm_out_mul)[0].ndim) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_1; + result_1.type_index = kTVMFFINone; + result_1.zero_padding = 0; + result_1.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_1) != 0) { + return -1; + } + } + if (!((bool)1)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "Symbolic shape variable num_tokens requires at least one non-null buffer among: mhc_pre_big_fuse_with_norm_tilelang.gemm_out_mul, mhc_pre_big_fuse_with_norm_tilelang.gemm_out_sqrsum, mhc_pre_big_fuse_with_norm_tilelang.residual, mhc_pre_big_fuse_with_norm_tilelang.post_mix, mhc_pre_big_fuse_with_norm_tilelang.comb_mix, mhc_pre_big_fuse_with_norm_tilelang.layer_input"); + return -1; + } + int32_t num_tokens = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]); + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides = (((DLTensor*)gemm_out_mul)[0].strides); + int32_t dev_id = (((DLTensor*)gemm_out_mul)[0].device.device_id); + void* gemm_out_mul_1 = (((DLTensor*)gemm_out_mul)[0].data); + if ((((DLTensor*)gemm_out_sqrsum)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_2; + result_2.type_index = kTVMFFINone; + result_2.zero_padding = 0; + result_2.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_2) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides = (((DLTensor*)gemm_out_sqrsum)[0].strides); + void* gemm_out_sqrsum_1 = (((DLTensor*)gemm_out_sqrsum)[0].data); + if ((((DLTensor*)hc_scale)[0].ndim) != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_3; + result_3.type_index = kTVMFFINone; + result_3.zero_padding = 0; + result_3.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_3) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides = (((DLTensor*)hc_scale)[0].strides); + void* hc_scale_1 = (((DLTensor*)hc_scale)[0].data); + if ((((DLTensor*)hc_base)[0].ndim) != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_4; + result_4.type_index = kTVMFFINone; + result_4.zero_padding = 0; + result_4.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_4) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides = (((DLTensor*)hc_base)[0].strides); + void* hc_base_1 = (((DLTensor*)hc_base)[0].data); + if ((((DLTensor*)residual)[0].ndim) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_5; + result_5.type_index = kTVMFFINone; + result_5.zero_padding = 0; + result_5.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_5) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_residual_strides = (((DLTensor*)residual)[0].strides); + void* residual_1 = (((DLTensor*)residual)[0].data); + if ((((DLTensor*)post_mix)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_6; + result_6.type_index = kTVMFFINone; + result_6.zero_padding = 0; + result_6.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_6) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides = (((DLTensor*)post_mix)[0].strides); + void* post_mix_1 = (((DLTensor*)post_mix)[0].data); + if ((((DLTensor*)comb_mix)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_7; + result_7.type_index = kTVMFFINone; + result_7.zero_padding = 0; + result_7.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_7) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides = (((DLTensor*)comb_mix)[0].strides); + void* comb_mix_1 = (((DLTensor*)comb_mix)[0].data); + if ((((DLTensor*)layer_input)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_8; + result_8.type_index = kTVMFFINone; + result_8.zero_padding = 0; + result_8.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_8) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides = (((DLTensor*)layer_input)[0].strides); + void* layer_input_1 = (((DLTensor*)layer_input)[0].data); + if ((((DLTensor*)norm_weight)[0].ndim) != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_9; + result_9.type_index = kTVMFFINone; + result_9.zero_padding = 0; + result_9.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_9) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides = (((DLTensor*)norm_weight)[0].strides); + void* norm_weight_1 = (((DLTensor*)norm_weight)[0].data); + if ((((((DLTensor*)gemm_out_mul)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)gemm_out_mul)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)gemm_out_mul)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_10; + result_10.type_index = kTVMFFINone; + result_10.zero_padding = 0; + result_10.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_10) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[0]) != 8) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)8; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_11; + result_11.type_index = kTVMFFINone; + result_11.zero_padding = 0; + result_11.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_11) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[2]) != 24) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)24; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[2])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_12; + result_12.type_index = kTVMFFINone; + result_12.zero_padding = 0; + result_12.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_12) != 0) { + return -1; + } + } + int32_t condval; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval = 1; + } else { + condval = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[2]); + } + if (condval != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_1; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval_1 = 1; + } else { + condval_1 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[2]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_1); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_13; + result_13.type_index = kTVMFFINone; + result_13.zero_padding = 0; + result_13.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_13) != 0) { + return -1; + } + } + int32_t condval_2; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval_2 = 1; + } else { + condval_2 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[1]); + } + if ((condval_2 != 24) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_14; + result_14.type_index = kTVMFFINone; + result_14.zero_padding = 0; + result_14.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_14) != 0) { + return -1; + } + } + int32_t condval_3; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval_3 = 1; + } else { + condval_3 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[0]); + } + if (((num_tokens * 24) != condval_3) && (num_tokens != 0)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_15; + result_15.type_index = kTVMFFINone; + result_15.zero_padding = 0; + result_15.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_15) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)gemm_out_mul)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_16; + result_16.type_index = kTVMFFINone; + result_16.zero_padding = 0; + result_16.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_16) != 0) { + return -1; + } + } + if ((((DLTensor*)gemm_out_mul)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_17; + result_17.type_index = kTVMFFINone; + result_17.zero_padding = 0; + result_17.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_17) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (gemm_out_mul_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_18; + result_18.type_index = kTVMFFINone; + result_18.zero_padding = 0; + result_18.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_18) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)gemm_out_sqrsum)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)gemm_out_sqrsum)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)gemm_out_sqrsum)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_19; + result_19.type_index = kTVMFFINone; + result_19.zero_padding = 0; + result_19.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_19) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[0]) != 8) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)8; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_20; + result_20.type_index = kTVMFFINone; + result_20.zero_padding = 0; + result_20.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_20) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[1])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_21; + result_21.type_index = kTVMFFINone; + result_21.zero_padding = 0; + result_21.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_21) != 0) { + return -1; + } + } + int32_t condval_4; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides == NULL)) { + condval_4 = 1; + } else { + condval_4 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides)[1]); + } + if ((condval_4 != 1) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_22; + result_22.type_index = kTVMFFINone; + result_22.zero_padding = 0; + result_22.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_22) != 0) { + return -1; + } + } + int32_t condval_5; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides == NULL)) { + condval_5 = 1; + } else { + condval_5 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides)[0]); + } + if ((((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != condval_5) && (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != 0)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_23; + result_23.type_index = kTVMFFINone; + result_23.zero_padding = 0; + result_23.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_23) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)gemm_out_sqrsum)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_24; + result_24.type_index = kTVMFFINone; + result_24.zero_padding = 0; + result_24.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_24) != 0) { + return -1; + } + } + if ((((DLTensor*)gemm_out_sqrsum)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_25; + result_25.type_index = kTVMFFINone; + result_25.zero_padding = 0; + result_25.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_25) != 0) { + return -1; + } + } + if ((((DLTensor*)gemm_out_sqrsum)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_26; + result_26.type_index = kTVMFFINone; + result_26.zero_padding = 0; + result_26.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_26) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (gemm_out_sqrsum_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_27; + result_27.type_index = kTVMFFINone; + result_27.zero_padding = 0; + result_27.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_27) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)hc_scale)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)hc_scale)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)hc_scale)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_28; + result_28.type_index = kTVMFFINone; + result_28.zero_padding = 0; + result_28.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_28) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_shape)[0]) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_29; + result_29.type_index = kTVMFFINone; + result_29.zero_padding = 0; + result_29.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_29) != 0) { + return -1; + } + } + int32_t condval_6; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides == NULL)) { + condval_6 = 1; + } else { + condval_6 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides)[0]); + } + if (condval_6 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_7; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides == NULL)) { + condval_7 = 1; + } else { + condval_7 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides)[0]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_7); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_30; + result_30.type_index = kTVMFFINone; + result_30.zero_padding = 0; + result_30.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_30) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)hc_scale)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_31; + result_31.type_index = kTVMFFINone; + result_31.zero_padding = 0; + result_31.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_31) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_scale)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_32; + result_32.type_index = kTVMFFINone; + result_32.zero_padding = 0; + result_32.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_32) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_scale)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_33; + result_33.type_index = kTVMFFINone; + result_33.zero_padding = 0; + result_33.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_33) != 0) { + return -1; + } + } + if (hc_scale_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_34; + result_34.type_index = kTVMFFINone; + result_34.zero_padding = 0; + result_34.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_34) != 0) { + return -1; + } + } + if ((((((DLTensor*)hc_base)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)hc_base)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)hc_base)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_35; + result_35.type_index = kTVMFFINone; + result_35.zero_padding = 0; + result_35.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_35) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_shape)[0]) != 24) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)24; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_36; + result_36.type_index = kTVMFFINone; + result_36.zero_padding = 0; + result_36.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_36) != 0) { + return -1; + } + } + int32_t condval_8; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides == NULL)) { + condval_8 = 1; + } else { + condval_8 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides)[0]); + } + if (condval_8 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_9; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides == NULL)) { + condval_9 = 1; + } else { + condval_9 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides)[0]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_9); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_37; + result_37.type_index = kTVMFFINone; + result_37.zero_padding = 0; + result_37.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_37) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)hc_base)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_38; + result_38.type_index = kTVMFFINone; + result_38.zero_padding = 0; + result_38.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_38) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_base)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_39; + result_39.type_index = kTVMFFINone; + result_39.zero_padding = 0; + result_39.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_39) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_base)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_40; + result_40.type_index = kTVMFFINone; + result_40.zero_padding = 0; + result_40.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_40) != 0) { + return -1; + } + } + if (hc_base_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_41; + result_41.type_index = kTVMFFINone; + result_41.zero_padding = 0; + result_41.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_41) != 0) { + return -1; + } + } + if ((((((DLTensor*)residual)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)residual)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)residual)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)residual)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)residual)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_42; + result_42.type_index = kTVMFFINone; + result_42.zero_padding = 0; + result_42.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_42) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_43; + result_43.type_index = kTVMFFINone; + result_43.zero_padding = 0; + result_43.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_43) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[1]) != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_44; + result_44.type_index = kTVMFFINone; + result_44.zero_padding = 0; + result_44.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_44) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[2]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[2])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_45; + result_45.type_index = kTVMFFINone; + result_45.zero_padding = 0; + result_45.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_45) != 0) { + return -1; + } + } + int32_t condval_10; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_10 = 1; + } else { + condval_10 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[2]); + } + if (condval_10 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_11; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_11 = 1; + } else { + condval_11 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[2]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_11); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_46; + result_46.type_index = kTVMFFINone; + result_46.zero_padding = 0; + result_46.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_46) != 0) { + return -1; + } + } + int32_t condval_12; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_12 = 1; + } else { + condval_12 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[1]); + } + if (condval_12 != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_13; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_13 = 1; + } else { + condval_13 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_13); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_47; + result_47.type_index = kTVMFFINone; + result_47.zero_padding = 0; + result_47.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_47) != 0) { + return -1; + } + } + int32_t condval_14; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_14 = 1; + } else { + condval_14 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[0]); + } + if ((condval_14 != 16384) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_48; + result_48.type_index = kTVMFFINone; + result_48.zero_padding = 0; + result_48.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_48) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)residual)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_49; + result_49.type_index = kTVMFFINone; + result_49.zero_padding = 0; + result_49.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_49) != 0) { + return -1; + } + } + if ((((DLTensor*)residual)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)residual)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_50; + result_50.type_index = kTVMFFINone; + result_50.zero_padding = 0; + result_50.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_50) != 0) { + return -1; + } + } + if ((((DLTensor*)residual)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_51; + result_51.type_index = kTVMFFINone; + result_51.zero_padding = 0; + result_51.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_51) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (residual_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_52; + result_52.type_index = kTVMFFINone; + result_52.zero_padding = 0; + result_52.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_52) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)post_mix)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)post_mix)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)post_mix)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_53; + result_53.type_index = kTVMFFINone; + result_53.zero_padding = 0; + result_53.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_53) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_54; + result_54.type_index = kTVMFFINone; + result_54.zero_padding = 0; + result_54.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_54) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[1]) != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_55; + result_55.type_index = kTVMFFINone; + result_55.zero_padding = 0; + result_55.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_55) != 0) { + return -1; + } + } + int32_t condval_15; + if ((mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides == NULL)) { + condval_15 = 1; + } else { + condval_15 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides)[1]); + } + if (condval_15 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_16; + if ((mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides == NULL)) { + condval_16 = 1; + } else { + condval_16 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_16); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_56; + result_56.type_index = kTVMFFINone; + result_56.zero_padding = 0; + result_56.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_56) != 0) { + return -1; + } + } + int32_t condval_17; + if ((mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides == NULL)) { + condval_17 = 1; + } else { + condval_17 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides)[0]); + } + if ((condval_17 != 4) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_57; + result_57.type_index = kTVMFFINone; + result_57.zero_padding = 0; + result_57.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_57) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)post_mix)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_58; + result_58.type_index = kTVMFFINone; + result_58.zero_padding = 0; + result_58.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_58) != 0) { + return -1; + } + } + if ((((DLTensor*)post_mix)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_59; + result_59.type_index = kTVMFFINone; + result_59.zero_padding = 0; + result_59.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_59) != 0) { + return -1; + } + } + if ((((DLTensor*)post_mix)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_60; + result_60.type_index = kTVMFFINone; + result_60.zero_padding = 0; + result_60.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_60) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (post_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_61; + result_61.type_index = kTVMFFINone; + result_61.zero_padding = 0; + result_61.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_61) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)comb_mix)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)comb_mix)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)comb_mix)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_62; + result_62.type_index = kTVMFFINone; + result_62.zero_padding = 0; + result_62.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_62) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_63; + result_63.type_index = kTVMFFINone; + result_63.zero_padding = 0; + result_63.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_63) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[1]) != 16) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_64; + result_64.type_index = kTVMFFINone; + result_64.zero_padding = 0; + result_64.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_64) != 0) { + return -1; + } + } + int32_t condval_18; + if ((mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides == NULL)) { + condval_18 = 1; + } else { + condval_18 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides)[1]); + } + if (condval_18 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_19; + if ((mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides == NULL)) { + condval_19 = 1; + } else { + condval_19 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_19); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_65; + result_65.type_index = kTVMFFINone; + result_65.zero_padding = 0; + result_65.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_65) != 0) { + return -1; + } + } + int32_t condval_20; + if ((mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides == NULL)) { + condval_20 = 1; + } else { + condval_20 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides)[0]); + } + if ((condval_20 != 16) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_66; + result_66.type_index = kTVMFFINone; + result_66.zero_padding = 0; + result_66.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_66) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)comb_mix)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_67; + result_67.type_index = kTVMFFINone; + result_67.zero_padding = 0; + result_67.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_67) != 0) { + return -1; + } + } + if ((((DLTensor*)comb_mix)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_68; + result_68.type_index = kTVMFFINone; + result_68.zero_padding = 0; + result_68.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_68) != 0) { + return -1; + } + } + if ((((DLTensor*)comb_mix)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_69; + result_69.type_index = kTVMFFINone; + result_69.zero_padding = 0; + result_69.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_69) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (comb_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_70; + result_70.type_index = kTVMFFINone; + result_70.zero_padding = 0; + result_70.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_70) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)layer_input)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)layer_input)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)layer_input)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_71; + result_71.type_index = kTVMFFINone; + result_71.zero_padding = 0; + result_71.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_71) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_72; + result_72.type_index = kTVMFFINone; + result_72.zero_padding = 0; + result_72.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_72) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[1]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_73; + result_73.type_index = kTVMFFINone; + result_73.zero_padding = 0; + result_73.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_73) != 0) { + return -1; + } + } + int32_t condval_21; + if ((mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides == NULL)) { + condval_21 = 1; + } else { + condval_21 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides)[1]); + } + if (condval_21 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_22; + if ((mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides == NULL)) { + condval_22 = 1; + } else { + condval_22 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_22); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_74; + result_74.type_index = kTVMFFINone; + result_74.zero_padding = 0; + result_74.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_74) != 0) { + return -1; + } + } + int32_t condval_23; + if ((mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides == NULL)) { + condval_23 = 1; + } else { + condval_23 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides)[0]); + } + if ((condval_23 != 4096) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_75; + result_75.type_index = kTVMFFINone; + result_75.zero_padding = 0; + result_75.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_75) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)layer_input)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_76; + result_76.type_index = kTVMFFINone; + result_76.zero_padding = 0; + result_76.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_76) != 0) { + return -1; + } + } + if ((((DLTensor*)layer_input)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_77; + result_77.type_index = kTVMFFINone; + result_77.zero_padding = 0; + result_77.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_77) != 0) { + return -1; + } + } + if ((((DLTensor*)layer_input)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_78; + result_78.type_index = kTVMFFINone; + result_78.zero_padding = 0; + result_78.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_78) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (layer_input_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_79; + result_79.type_index = kTVMFFINone; + result_79.zero_padding = 0; + result_79.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_79) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)norm_weight)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)norm_weight)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)norm_weight)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_80; + result_80.type_index = kTVMFFINone; + result_80.zero_padding = 0; + result_80.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_80) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_shape)[0]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_81; + result_81.type_index = kTVMFFINone; + result_81.zero_padding = 0; + result_81.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_81) != 0) { + return -1; + } + } + int32_t condval_24; + if ((mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides == NULL)) { + condval_24 = 1; + } else { + condval_24 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides)[0]); + } + if (condval_24 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_25; + if ((mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides == NULL)) { + condval_25 = 1; + } else { + condval_25 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides)[0]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_25); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_82; + result_82.type_index = kTVMFFINone; + result_82.zero_padding = 0; + result_82.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_82) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)norm_weight)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_83; + result_83.type_index = kTVMFFINone; + result_83.zero_padding = 0; + result_83.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_83) != 0) { + return -1; + } + } + if ((((DLTensor*)norm_weight)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_84; + result_84.type_index = kTVMFFINone; + result_84.zero_padding = 0; + result_84.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_84) != 0) { + return -1; + } + } + if ((((DLTensor*)norm_weight)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_85; + result_85.type_index = kTVMFFINone; + result_85.zero_padding = 0; + result_85.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_85) != 0) { + return -1; + } + } + if (norm_weight_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_86; + result_86.type_index = kTVMFFINone; + result_86.zero_padding = 0; + result_86.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_86) != 0) { + return -1; + } + } + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = ((int64_t)2); + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = ((int64_t)dev_id); + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + if (__tvm_set_device_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_set_device", &__tvm_set_device_packed) != 0) { + return -1; + } + } + TVMFFIAny result_87; + result_87.type_index = kTVMFFINone; + result_87.zero_padding = 0; + result_87.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_set_device_packed, (TVMFFIAny*) stack_ffi_any, 2, &result_87) != 0) { + return -1; + } + if (comb_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = comb_mix_1; + if (gemm_out_mul_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = gemm_out_mul_1; + if (gemm_out_sqrsum_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = gemm_out_sqrsum_1; + if (hc_base_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_ptr) = hc_base_1; + if (hc_scale_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_ptr) = hc_scale_1; + if (layer_input_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_ptr) = layer_input_1; + if (norm_weight_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_ptr) = norm_weight_1; + if (post_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_ptr) = post_mix_1; + if (residual_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_ptr) = residual_1; + (((TVMFFIAny*)stack_ffi_any)[9].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[9].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[9].v_int64) = ((int64_t)num_tokens); + (((TVMFFIAny*)stack_ffi_any)[10].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[10].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[10].v_int64) = ((int64_t)num_tokens); + (((TVMFFIAny*)stack_ffi_any)[11].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[11].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[11].v_int64) = ((int64_t)96); + (((TVMFFIAny*)stack_ffi_any)[12].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[12].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[12].v_int64) = ((int64_t)1); + (((TVMFFIAny*)stack_ffi_any)[13].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[13].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[13].v_int64) = ((int64_t)1); + (((TVMFFIAny*)stack_ffi_any)[14].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[14].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[14].v_int64) = ((int64_t)29040); + (((TVMFFIAny*)stack_ffi_any)[15].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[15].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[15].v_int64) = (int64_t)0; + if (mhc_pre_big_fuse_with_norm_tilelang_kernel_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "mhc_pre_big_fuse_with_norm_tilelang_kernel", &mhc_pre_big_fuse_with_norm_tilelang_kernel_packed) != 0) { + return -1; + } + } + TVMFFIAny result_88; + result_88.type_index = kTVMFFINone; + result_88.zero_padding = 0; + result_88.v_int64 = 0; + if (TVMFFIFunctionCall(mhc_pre_big_fuse_with_norm_tilelang_kernel_packed, (TVMFFIAny*) stack_ffi_any, 15, &result_88) != 0) { + return -1; + } + return 0; +} + +// CodegenC: NOTE: Auto-generated entry function +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_main(void* self, void* args,int num_args, void* result) { + return __tvm_ffi_mhc_pre_big_fuse_with_norm_tilelang(self, args, num_args, result); +} diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/455ef1b63b3a592f4741c938fcfb8d01f90e8269880307cffbf4438ed668de0b/params.pkl b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/455ef1b63b3a592f4741c938fcfb8d01f90e8269880307cffbf4438ed668de0b/params.pkl new file mode 100644 index 0000000..83d1996 Binary files /dev/null and b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/455ef1b63b3a592f4741c938fcfb8d01f90e8269880307cffbf4438ed668de0b/params.pkl differ diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/47c189497f8ff487a170b06db17717920a83856d30485b87094ce9d42596885b/device_kernel.cu b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/47c189497f8ff487a170b06db17717920a83856d30485b87094ce9d42596885b/device_kernel.cu new file mode 100644 index 0000000..1e15dbf --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/47c189497f8ff487a170b06db17717920a83856d30485b87094ce9d42596885b/device_kernel.cu @@ -0,0 +1,424 @@ +#include +#include +#include +#include +#include +#include +#include +#ifdef ENABLE_BF16 +#include +#endif + +extern "C" __global__ void mhc_pre_big_fuse_with_norm_tilelang_kernel(float* comb_mix, const float* gemm_out_mul, const float* gemm_out_sqrsum, const float* hc_base, const float* hc_scale, bfloat16_t* layer_input, const bfloat16_t* norm_weight, float* post_mix, const bfloat16_t* residual, int num_tokens); +extern "C" __global__ void __launch_bounds__(96, 1) mhc_pre_big_fuse_with_norm_tilelang_kernel(float* comb_mix, const float* gemm_out_mul, const float* gemm_out_sqrsum, const float* hc_base, const float* hc_scale, bfloat16_t* layer_input, const bfloat16_t* norm_weight, float* post_mix, const bfloat16_t* residual, int num_tokens) { + extern __shared__ __align__(1024) uchar buf_dyn_shmem[]; + float mixes[1]; + float rms[1]; + float cm[1]; + float row_max[1]; + float row_sum[1]; + float col_sum[1]; + float sumsq_per_pos[16]; + float sumsq[1]; + float rsqrt_norm[1]; + float xl[64]; + float ol[16]; + bfloat16_t xs_local_cast[8]; + bfloat16_t xs_local_cast_1[8]; + bfloat16_t xs_local_cast_2[8]; + float w_local[16]; + float ol_1[16]; + bfloat16_t w_shared_local_cast_3[8]; + bfloat16_t output_shared_local_cast_4[8]; + bfloat16_t layer_input_local_cast_5[8]; + bfloat16_t w_shared_local_cast_6[8]; + bfloat16_t output_shared_local_cast_7[8]; + bfloat16_t layer_input_local_cast_8[8]; + bfloat16_t w_shared_local_cast_9[8]; + bfloat16_t output_shared_local_cast_10[8]; + bfloat16_t layer_input_local_cast_11[8]; + mixes[0] = 0x0p+0f/*0.000000e+00*/; + rms[0] = 0x0p+0f/*0.000000e+00*/; + cudaGridDependencySynchronize(); + for (int i_split = 0; i_split < 4; ++i_split) { + rms[0] = (rms[0] + gemm_out_sqrsum[((((int64_t)i_split) * ((int64_t)num_tokens)) + ((int64_t)((int)blockIdx.x)))]); + } + rms[0] = rsqrtf(((rms[0] / 0x1p+14f/*1.638400e+04*/) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + mixes[0] = 0x0p+0f/*0.000000e+00*/; + for (int i_split_1 = 0; i_split_1 < 4; ++i_split_1) { + mixes[0] = (mixes[0] + gemm_out_mul[(((((int64_t)((int)blockIdx.x)) * (int64_t)24) + ((((int64_t)i_split_1) * ((int64_t)num_tokens)) * (int64_t)24)) + (((int64_t)((int)threadIdx.x)) % (int64_t)24))]); + } + mixes[0] = (mixes[0] * rms[0]); + if ((((int)threadIdx.x) / 24) == 0) { + ((float*)buf_dyn_shmem)[(((int)threadIdx.x) % 24)] = mixes[0]; + } + __syncthreads(); + if (((int)threadIdx.x) < 32) { + if (((int)threadIdx.x) < 4) { + post_mix[((((int64_t)((int)blockIdx.x)) * (int64_t)4) + ((int64_t)((int)threadIdx.x)))] = ((0x1p+0f/*1.000000e+00*/ / (0x1p+0f/*1.000000e+00*/ + expf((0x0p+0f/*0.000000e+00*/ - ((((float*)buf_dyn_shmem)[(((int)threadIdx.x) + 4)] * hc_scale[1]) + hc_base[(((int)threadIdx.x) + 4)]))))) * 0x1p+1f/*2.000000e+00*/); + } + cm[0] = ((((float*)buf_dyn_shmem)[((((int)threadIdx.x) & 15) + 8)] * hc_scale[2]) + hc_base[((((int)threadIdx.x) & 15) + 8)]); + row_max[0] = -CUDART_INF_F; + row_max[0] = max(row_max[0], cm[0]); + row_max[0] = tl::AllReduce>::run(row_max[0]); + cm[0] = expf((cm[0] - row_max[0])); + row_sum[0] = 0x0p+0f/*0.000000e+00*/; + row_sum[0] = (row_sum[0] + cm[0]); + row_sum[0] = tl::AllReduce>::run(row_sum[0]); + cm[0] = ((cm[0] / row_sum[0]) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/); + col_sum[0] = 0x0p+0f/*0.000000e+00*/; + col_sum[0] = (col_sum[0] + cm[0]); + col_sum[0] = tl::AllReduce>::run(col_sum[0]); + cm[0] = (cm[0] / (col_sum[0] + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + for (int __1 = 0; __1 < 19; ++__1) { + row_sum[0] = 0x0p+0f/*0.000000e+00*/; + row_sum[0] = (row_sum[0] + cm[0]); + row_sum[0] = tl::AllReduce>::run(row_sum[0]); + cm[0] = (cm[0] / (row_sum[0] + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + col_sum[0] = 0x0p+0f/*0.000000e+00*/; + col_sum[0] = (col_sum[0] + cm[0]); + col_sum[0] = tl::AllReduce>::run(col_sum[0]); + cm[0] = (cm[0] / (col_sum[0] + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + } + if ((((int)threadIdx.x) >> 4) == 0) { + comb_mix[((((int64_t)((int)blockIdx.x)) * (int64_t)16) + (((int64_t)((int)threadIdx.x)) & (int64_t)15))] = cm[0]; + } + } else { + if (((int)threadIdx.x) < 36) { + ((float*)buf_dyn_shmem)[(((int)threadIdx.x) + 7224)] = ((0x1p+0f/*1.000000e+00*/ / (0x1p+0f/*1.000000e+00*/ + expf((0x0p+0f/*0.000000e+00*/ - ((((float*)buf_dyn_shmem)[(((int)threadIdx.x) - 32)] * hc_scale[0]) + hc_base[(((int)threadIdx.x) - 32)]))))) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/); + } + #pragma unroll + for (int i = 0; i < 4; ++i) { + float broadcast_var = 0x0p+0f/*0.000000e+00*/; + *(float4*)(sumsq_per_pos + (i * 4)) = make_float4(broadcast_var, broadcast_var, broadcast_var, broadcast_var); + } + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_1 = 0; i_1 < 8; ++i_1) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i_1 >> 1) * 1024) + (((((i_1 * 64) + ((int)threadIdx.x)) + 96) & 127) * 8)) + 48)])), (&(residual[(((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + ((((int64_t)i_1) >> (int64_t)1) * (int64_t)4096)) + (((((((int64_t)i_1) * (int64_t)64) + ((int64_t)((int)threadIdx.x))) + (int64_t)96) & (int64_t)127) * (int64_t)8))]))); + } + tl::cp_async_commit(); + #pragma unroll + for (int i_2 = 0; i_2 < 8; ++i_2) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i_2 >> 1) * 1024) + (((((i_2 * 64) + ((int)threadIdx.x)) + 96) & 127) * 8)) + 4144)])), (&(residual[((((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + ((((int64_t)i_2) >> (int64_t)1) * (int64_t)4096)) + (((((((int64_t)i_2) * (int64_t)64) + ((int64_t)((int)threadIdx.x))) + (int64_t)96) & (int64_t)127) * (int64_t)8)) + (int64_t)1024)]))); + } + tl::cp_async_commit(); + for (int i0_h = 0; i0_h < 2; ++i0_h) { + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_3 = 0; i_3 < 8; ++i_3) { + *(uint4*)(xs_local_cast + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + ((((i0_h * 4096) + (i_3 * 512)) + (((int)threadIdx.x) * 8)) - 208)); + for (int vec = 0; vec < 2; ++vec) { + float4 __2; + uint2 v_ = *(uint2*)(xs_local_cast + (vec * 4)); + ((float2*)(&__2))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v_))[0]); + ((float2*)(&__2))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v_))[1]); + *(float4*)(xl + ((i_3 * 8) + (vec * 4))) = __2; + } + } + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_4 = 0; i_4 < 8; ++i_4) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i0_h * 4096) + ((i_4 >> 1) * 1024)) + (((((i_4 * 64) + ((int)threadIdx.x)) + 96) & 127) * 8)) + 48)])), (&(residual[(((((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + ((((int64_t)i_4) >> (int64_t)1) * (int64_t)4096)) + (((int64_t)i0_h) * (int64_t)1024)) + (((((((int64_t)i_4) * (int64_t)64) + ((int64_t)((int)threadIdx.x))) + (int64_t)96) & (int64_t)127) * (int64_t)8)) + (int64_t)2048)]))); + } + tl::cp_async_commit(); + #pragma unroll + for (int i_5 = 0; i_5 < 4; ++i_5) { + float broadcast_var_1 = 0x0p+0f/*0.000000e+00*/; + *(float4*)(ol + (i_5 * 4)) = make_float4(broadcast_var_1, broadcast_var_1, broadcast_var_1, broadcast_var_1); + } + tl::__sync_thread_partial<3, 64>(); + for (int i_hc = 0; i_hc < 4; ++i_hc) { + float pre = ((float*)buf_dyn_shmem)[(i_hc + 7256)]; + #pragma unroll + for (int i_6 = 0; i_6 < 16; ++i_6) { + ol[i_6] = (ol[i_6] + (pre * xl[((i_hc * 16) + i_6)])); + } + } + #pragma unroll + for (int i_7 = 0; i_7 < 4; ++i_7) { + float4 __3; + float4 v__1 = *(float4*)(sumsq_per_pos + (i_7 * 4)); + float4 __4; + float4 v__2 = *(float4*)(ol + (i_7 * 4)); + __4.x = (v__2.x*v__2.x); + __4.y = (v__2.y*v__2.y); + __4.z = (v__2.z*v__2.z); + __4.w = (v__2.w*v__2.w); + __3.x = (v__1.x+__4.x); + __3.y = (v__1.y+__4.y); + __3.z = (v__1.z+__4.z); + __3.w = (v__1.w+__4.w); + *(float4*)(sumsq_per_pos + (i_7 * 4)) = __3; + uint2 __5; + float4 v__3 = *(float4*)(ol + (i_7 * 4)); + (reinterpret_cast<__nv_bfloat162*>(&__5))[0] = __float22bfloat162_rn(((float2*)(&v__3))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__5))[1] = __float22bfloat162_rn(((float2*)(&v__3))[1]); + *(uint2*)(((bfloat16_t*)buf_dyn_shmem) + (((((i0_h * 1024) + ((i_7 >> 1) * 512)) + (((int)threadIdx.x) * 8)) + ((i_7 & 1) * 4)) + 7984)) = __5; + } + } + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_8 = 0; i_8 < 8; ++i_8) { + *(uint4*)(xs_local_cast_1 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_8 * 512) + (((int)threadIdx.x) * 8)) - 208)); + for (int vec_1 = 0; vec_1 < 2; ++vec_1) { + float4 __6; + uint2 v__4 = *(uint2*)(xs_local_cast_1 + (vec_1 * 4)); + ((float2*)(&__6))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__4))[0]); + ((float2*)(&__6))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__4))[1]); + *(float4*)(xl + ((i_8 * 8) + (vec_1 * 4))) = __6; + } + } + #pragma unroll + for (int i_9 = 0; i_9 < 4; ++i_9) { + float broadcast_var_2 = 0x0p+0f/*0.000000e+00*/; + *(float4*)(ol + (i_9 * 4)) = make_float4(broadcast_var_2, broadcast_var_2, broadcast_var_2, broadcast_var_2); + } + for (int i_hc_1 = 0; i_hc_1 < 4; ++i_hc_1) { + float pre_1 = ((float*)buf_dyn_shmem)[(i_hc_1 + 7256)]; + #pragma unroll + for (int i_10 = 0; i_10 < 16; ++i_10) { + ol[i_10] = (ol[i_10] + (pre_1 * xl[((i_hc_1 * 16) + i_10)])); + } + } + #pragma unroll + for (int i_11 = 0; i_11 < 4; ++i_11) { + float4 __7; + float4 v__5 = *(float4*)(sumsq_per_pos + (i_11 * 4)); + float4 __8; + float4 v__6 = *(float4*)(ol + (i_11 * 4)); + __8.x = (v__6.x*v__6.x); + __8.y = (v__6.y*v__6.y); + __8.z = (v__6.z*v__6.z); + __8.w = (v__6.w*v__6.w); + __7.x = (v__5.x+__8.x); + __7.y = (v__5.y+__8.y); + __7.z = (v__5.z+__8.z); + __7.w = (v__5.w+__8.w); + *(float4*)(sumsq_per_pos + (i_11 * 4)) = __7; + uint2 __9; + float4 v__7 = *(float4*)(ol + (i_11 * 4)); + (reinterpret_cast<__nv_bfloat162*>(&__9))[0] = __float22bfloat162_rn(((float2*)(&v__7))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__9))[1] = __float22bfloat162_rn(((float2*)(&v__7))[1]); + *(uint2*)(((bfloat16_t*)buf_dyn_shmem) + (((((i_11 >> 1) * 512) + (((int)threadIdx.x) * 8)) + ((i_11 & 1) * 4)) + 10032)) = __9; + } + tl::cp_async_wait<0>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_12 = 0; i_12 < 8; ++i_12) { + *(uint4*)(xs_local_cast_2 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_12 * 512) + (((int)threadIdx.x) * 8)) + 3888)); + for (int vec_2 = 0; vec_2 < 2; ++vec_2) { + float4 __10; + uint2 v__8 = *(uint2*)(xs_local_cast_2 + (vec_2 * 4)); + ((float2*)(&__10))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__8))[0]); + ((float2*)(&__10))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__8))[1]); + *(float4*)(xl + ((i_12 * 8) + (vec_2 * 4))) = __10; + } + } + #pragma unroll + for (int i_13 = 0; i_13 < 4; ++i_13) { + float broadcast_var_3 = 0x0p+0f/*0.000000e+00*/; + *(float4*)(ol + (i_13 * 4)) = make_float4(broadcast_var_3, broadcast_var_3, broadcast_var_3, broadcast_var_3); + } + for (int i_hc_2 = 0; i_hc_2 < 4; ++i_hc_2) { + float pre_2 = ((float*)buf_dyn_shmem)[(i_hc_2 + 7256)]; + #pragma unroll + for (int i_14 = 0; i_14 < 16; ++i_14) { + ol[i_14] = (ol[i_14] + (pre_2 * xl[((i_hc_2 * 16) + i_14)])); + } + } + #pragma unroll + for (int i_15 = 0; i_15 < 4; ++i_15) { + float4 __11; + float4 v__9 = *(float4*)(sumsq_per_pos + (i_15 * 4)); + float4 __12; + float4 v__10 = *(float4*)(ol + (i_15 * 4)); + __12.x = (v__10.x*v__10.x); + __12.y = (v__10.y*v__10.y); + __12.z = (v__10.z*v__10.z); + __12.w = (v__10.w*v__10.w); + __11.x = (v__9.x+__12.x); + __11.y = (v__9.y+__12.y); + __11.z = (v__9.z+__12.z); + __11.w = (v__9.w+__12.w); + *(float4*)(sumsq_per_pos + (i_15 * 4)) = __11; + uint2 __13; + float4 v__11 = *(float4*)(ol + (i_15 * 4)); + (reinterpret_cast<__nv_bfloat162*>(&__13))[0] = __float22bfloat162_rn(((float2*)(&v__11))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__13))[1] = __float22bfloat162_rn(((float2*)(&v__11))[1]); + *(uint2*)(((bfloat16_t*)buf_dyn_shmem) + (((((i_15 >> 1) * 512) + (((int)threadIdx.x) * 8)) + ((i_15 & 1) * 4)) + 11056)) = __13; + } + sumsq[0] = 0x0p+0f/*0.000000e+00*/; + #pragma unroll + for (int rv = 0; rv < 16; ++rv) { + sumsq[0] = (sumsq[0] + sumsq_per_pos[(((rv & 1) * 8) + (rv >> 1))]); + } + tl::__sync_thread_partial<3, 64>(); + sumsq[0] = tl::AllReduce>::run(sumsq[0], (&(((float*)buf_dyn_shmem)[7192]))); + rsqrt_norm[0] = rsqrtf(((sumsq[0] / 0x1p+12f/*4.096000e+03*/) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + #pragma unroll + for (int i_16 = 0; i_16 < 2; ++i_16) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[(((i_16 * 512) + (((int)threadIdx.x) * 8)) + 12080)])), (&(norm_weight[(((i_16 * 512) + (((int)threadIdx.x) * 8)) - 256)]))); + } + tl::cp_async_commit(); + #pragma unroll + for (int i_17 = 0; i_17 < 2; ++i_17) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[(((i_17 * 512) + (((int)threadIdx.x) * 8)) + 13104)])), (&(norm_weight[(((i_17 * 512) + (((int)threadIdx.x) * 8)) + 768)]))); + } + tl::cp_async_commit(); + for (int i0_h_1 = 0; i0_h_1 < 2; ++i0_h_1) { + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_18 = 0; i_18 < 2; ++i_18) { + *(uint4*)(w_shared_local_cast_3 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + ((((i0_h_1 * 1024) + (i_18 * 512)) + (((int)threadIdx.x) * 8)) + 12080)); + for (int vec_3 = 0; vec_3 < 2; ++vec_3) { + float4 __14; + uint2 v__12 = *(uint2*)(w_shared_local_cast_3 + (vec_3 * 4)); + ((float2*)(&__14))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__12))[0]); + ((float2*)(&__14))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__12))[1]); + *(float4*)(w_local + ((i_18 * 8) + (vec_3 * 4))) = __14; + } + } + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_19 = 0; i_19 < 2; ++i_19) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i0_h_1 * 1024) + (i_19 * 512)) + (((int)threadIdx.x) * 8)) + 12080)])), (&(norm_weight[((((i0_h_1 * 1024) + (i_19 * 512)) + (((int)threadIdx.x) * 8)) + 1792)]))); + } + tl::cp_async_commit(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_20 = 0; i_20 < 2; ++i_20) { + *(uint4*)(output_shared_local_cast_4 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + ((((i0_h_1 * 1024) + (i_20 * 512)) + (((int)threadIdx.x) * 8)) + 7984)); + for (int vec_4 = 0; vec_4 < 2; ++vec_4) { + float4 __15; + float4 __16; + float4 __17; + uint2 v__13 = *(uint2*)(output_shared_local_cast_4 + (vec_4 * 4)); + ((float2*)(&__17))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__13))[0]); + ((float2*)(&__17))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__13))[1]); + float4 v__14 = make_float4(rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0]); + __16.x = (__17.x*v__14.x); + __16.y = (__17.y*v__14.y); + __16.z = (__17.z*v__14.z); + __16.w = (__17.w*v__14.w); + float4 v__15 = *(float4*)(w_local + ((i_20 * 8) + (vec_4 * 4))); + __15.x = (__16.x*v__15.x); + __15.y = (__16.y*v__15.y); + __15.z = (__16.z*v__15.z); + __15.w = (__16.w*v__15.w); + *(float4*)(ol_1 + ((i_20 * 8) + (vec_4 * 4))) = __15; + } + } + #pragma unroll + for (int i_21 = 0; i_21 < 2; ++i_21) { + for (int vec_5 = 0; vec_5 < 2; ++vec_5) { + uint2 __18; + float4 v__16 = *(float4*)(ol_1 + ((i_21 * 8) + (vec_5 * 4))); + (reinterpret_cast<__nv_bfloat162*>(&__18))[0] = __float22bfloat162_rn(((float2*)(&v__16))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__18))[1] = __float22bfloat162_rn(((float2*)(&v__16))[1]); + *(uint2*)(layer_input_local_cast_5 + (vec_5 * 4)) = __18; + } + *(uint4*)(layer_input + (((((((int64_t)((int)blockIdx.x)) * (int64_t)4096) + (((int64_t)i0_h_1) * (int64_t)1024)) + (((int64_t)i_21) * (int64_t)512)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8)) - (int64_t)256)) = *(uint4*)(layer_input_local_cast_5 + 0); + } + } + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_22 = 0; i_22 < 2; ++i_22) { + *(uint4*)(w_shared_local_cast_6 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_22 * 512) + (((int)threadIdx.x) * 8)) + 12080)); + for (int vec_6 = 0; vec_6 < 2; ++vec_6) { + float4 __19; + uint2 v__17 = *(uint2*)(w_shared_local_cast_6 + (vec_6 * 4)); + ((float2*)(&__19))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__17))[0]); + ((float2*)(&__19))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__17))[1]); + *(float4*)(w_local + ((i_22 * 8) + (vec_6 * 4))) = __19; + } + } + #pragma unroll + for (int i_23 = 0; i_23 < 2; ++i_23) { + *(uint4*)(output_shared_local_cast_7 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_23 * 512) + (((int)threadIdx.x) * 8)) + 10032)); + for (int vec_7 = 0; vec_7 < 2; ++vec_7) { + float4 __20; + float4 __21; + float4 __22; + uint2 v__18 = *(uint2*)(output_shared_local_cast_7 + (vec_7 * 4)); + ((float2*)(&__22))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__18))[0]); + ((float2*)(&__22))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__18))[1]); + float4 v__19 = make_float4(rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0]); + __21.x = (__22.x*v__19.x); + __21.y = (__22.y*v__19.y); + __21.z = (__22.z*v__19.z); + __21.w = (__22.w*v__19.w); + float4 v__20 = *(float4*)(w_local + ((i_23 * 8) + (vec_7 * 4))); + __20.x = (__21.x*v__20.x); + __20.y = (__21.y*v__20.y); + __20.z = (__21.z*v__20.z); + __20.w = (__21.w*v__20.w); + *(float4*)(ol_1 + ((i_23 * 8) + (vec_7 * 4))) = __20; + } + } + #pragma unroll + for (int i_24 = 0; i_24 < 2; ++i_24) { + for (int vec_8 = 0; vec_8 < 2; ++vec_8) { + uint2 __23; + float4 v__21 = *(float4*)(ol_1 + ((i_24 * 8) + (vec_8 * 4))); + (reinterpret_cast<__nv_bfloat162*>(&__23))[0] = __float22bfloat162_rn(((float2*)(&v__21))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__23))[1] = __float22bfloat162_rn(((float2*)(&v__21))[1]); + *(uint2*)(layer_input_local_cast_8 + (vec_8 * 4)) = __23; + } + *(uint4*)(layer_input + ((((((int64_t)((int)blockIdx.x)) * (int64_t)4096) + (((int64_t)i_24) * (int64_t)512)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8)) + (int64_t)1792)) = *(uint4*)(layer_input_local_cast_8 + 0); + } + tl::cp_async_wait<0>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_25 = 0; i_25 < 2; ++i_25) { + *(uint4*)(w_shared_local_cast_9 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_25 * 512) + (((int)threadIdx.x) * 8)) + 13104)); + for (int vec_9 = 0; vec_9 < 2; ++vec_9) { + float4 __24; + uint2 v__22 = *(uint2*)(w_shared_local_cast_9 + (vec_9 * 4)); + ((float2*)(&__24))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__22))[0]); + ((float2*)(&__24))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__22))[1]); + *(float4*)(w_local + ((i_25 * 8) + (vec_9 * 4))) = __24; + } + } + #pragma unroll + for (int i_26 = 0; i_26 < 2; ++i_26) { + *(uint4*)(output_shared_local_cast_10 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_26 * 512) + (((int)threadIdx.x) * 8)) + 11056)); + for (int vec_10 = 0; vec_10 < 2; ++vec_10) { + float4 __25; + float4 __26; + float4 __27; + uint2 v__23 = *(uint2*)(output_shared_local_cast_10 + (vec_10 * 4)); + ((float2*)(&__27))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__23))[0]); + ((float2*)(&__27))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__23))[1]); + float4 v__24 = make_float4(rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0]); + __26.x = (__27.x*v__24.x); + __26.y = (__27.y*v__24.y); + __26.z = (__27.z*v__24.z); + __26.w = (__27.w*v__24.w); + float4 v__25 = *(float4*)(w_local + ((i_26 * 8) + (vec_10 * 4))); + __25.x = (__26.x*v__25.x); + __25.y = (__26.y*v__25.y); + __25.z = (__26.z*v__25.z); + __25.w = (__26.w*v__25.w); + *(float4*)(ol_1 + ((i_26 * 8) + (vec_10 * 4))) = __25; + } + } + #pragma unroll + for (int i_27 = 0; i_27 < 2; ++i_27) { + for (int vec_11 = 0; vec_11 < 2; ++vec_11) { + uint2 __28; + float4 v__26 = *(float4*)(ol_1 + ((i_27 * 8) + (vec_11 * 4))); + (reinterpret_cast<__nv_bfloat162*>(&__28))[0] = __float22bfloat162_rn(((float2*)(&v__26))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__28))[1] = __float22bfloat162_rn(((float2*)(&v__26))[1]); + *(uint2*)(layer_input_local_cast_11 + (vec_11 * 4)) = __28; + } + *(uint4*)(layer_input + ((((((int64_t)((int)blockIdx.x)) * (int64_t)4096) + (((int64_t)i_27) * (int64_t)512)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8)) + (int64_t)2816)) = *(uint4*)(layer_input_local_cast_11 + 0); + } + } + cudaTriggerProgrammaticLaunchCompletion(); +} + diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/47c189497f8ff487a170b06db17717920a83856d30485b87094ce9d42596885b/host_kernel.cu b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/47c189497f8ff487a170b06db17717920a83856d30485b87094ce9d42596885b/host_kernel.cu new file mode 100644 index 0000000..825ac07 --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/47c189497f8ff487a170b06db17717920a83856d30485b87094ce9d42596885b/host_kernel.cu @@ -0,0 +1,3359 @@ +// tilelang target: c -keys=cpu +#define TVM_EXPORTS +#include "tvm/runtime/base.h" +#include "tvm/runtime/c_backend_api.h" +#include "tvm/ffi/c_api.h" +#include +#include +#include +#ifdef __OBJC__ +#include "tvm/runtime/device_api.h" +#include "tvm/ffi/function.h" +#include +#include +#include +#endif +void* __tvm_ffi__library_ctx = NULL; +static void* __tvm_error_ndim_mismatch_packed = NULL; +static void* __tvm_error_dtype_mismatch_packed = NULL; +static void* __tvm_error_expect_eq_packed = NULL; +static void* __tvm_error_constraint_violation_packed = NULL; +static void* __tvm_error_byte_offset_mismatch_packed = NULL; +static void* __tvm_error_device_type_mismatch_packed = NULL; +static void* __tvm_error_null_ptr_packed = NULL; +static void* __tvm_set_device_packed = NULL; +static void* mhc_pre_big_fuse_with_norm_tilelang_kernel_packed = NULL; +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_mhc_pre_big_fuse_with_norm_tilelang(void* self_handle, void* args, int32_t num_args, void* result); +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_mhc_pre_big_fuse_with_norm_tilelang(void* self_handle, void* args, int32_t num_args, void* result) { + __attribute__((aligned(64))) TVMFFIAny stack[16]; + void* stack_ffi_any = stack; + if (!((num_args == 9))) { + char __tvm_assert_msg_buf[512]; + snprintf(__tvm_assert_msg_buf, 512, "%s; expected: %lld, got: %lld", "mhc_pre_big_fuse_with_norm_tilelang: num_args should be 9", (long long)(num_args), (long long)(9)); + TVMFFIErrorSetRaisedFromCStr("RuntimeError", __tvm_assert_msg_buf); + return -1; + } + if (!(!(args == NULL))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang: args pointer is NULL"); + return -1; + } + int32_t gemm_out_mul_type_index = (((TVMFFIAny*)args)[0].type_index); + if (!(((((gemm_out_mul_type_index == 0) || (gemm_out_mul_type_index == 4)) || (gemm_out_mul_type_index == 7)) || (64 <= gemm_out_mul_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input gemm_out_mul expected pointer or tensor handle"); + return -1; + } + int32_t gemm_out_sqrsum_type_index = (((TVMFFIAny*)args)[1].type_index); + if (!(((((gemm_out_sqrsum_type_index == 0) || (gemm_out_sqrsum_type_index == 4)) || (gemm_out_sqrsum_type_index == 7)) || (64 <= gemm_out_sqrsum_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input gemm_out_sqrsum expected pointer or tensor handle"); + return -1; + } + int32_t hc_scale_type_index = (((TVMFFIAny*)args)[2].type_index); + if (!(((((hc_scale_type_index == 0) || (hc_scale_type_index == 4)) || (hc_scale_type_index == 7)) || (64 <= hc_scale_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input hc_scale expected pointer or tensor handle"); + return -1; + } + int32_t hc_base_type_index = (((TVMFFIAny*)args)[3].type_index); + if (!(((((hc_base_type_index == 0) || (hc_base_type_index == 4)) || (hc_base_type_index == 7)) || (64 <= hc_base_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input hc_base expected pointer or tensor handle"); + return -1; + } + int32_t residual_type_index = (((TVMFFIAny*)args)[4].type_index); + if (!(((((residual_type_index == 0) || (residual_type_index == 4)) || (residual_type_index == 7)) || (64 <= residual_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input residual expected pointer or tensor handle"); + return -1; + } + int32_t post_mix_type_index = (((TVMFFIAny*)args)[5].type_index); + if (!(((((post_mix_type_index == 0) || (post_mix_type_index == 4)) || (post_mix_type_index == 7)) || (64 <= post_mix_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input post_mix expected pointer or tensor handle"); + return -1; + } + int32_t comb_mix_type_index = (((TVMFFIAny*)args)[6].type_index); + if (!(((((comb_mix_type_index == 0) || (comb_mix_type_index == 4)) || (comb_mix_type_index == 7)) || (64 <= comb_mix_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input comb_mix expected pointer or tensor handle"); + return -1; + } + int32_t layer_input_type_index = (((TVMFFIAny*)args)[7].type_index); + if (!(((((layer_input_type_index == 0) || (layer_input_type_index == 4)) || (layer_input_type_index == 7)) || (64 <= layer_input_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input layer_input expected pointer or tensor handle"); + return -1; + } + int32_t norm_weight_type_index = (((TVMFFIAny*)args)[8].type_index); + if (!(((((norm_weight_type_index == 0) || (norm_weight_type_index == 4)) || (norm_weight_type_index == 7)) || (64 <= norm_weight_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input norm_weight expected pointer or tensor handle"); + return -1; + } + void* gemm_out_mul = ((gemm_out_mul_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[0].v_ptr) + 24)) : (((TVMFFIAny*)args)[0].v_ptr)); + void* gemm_out_sqrsum = ((gemm_out_sqrsum_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[1].v_ptr) + 24)) : (((TVMFFIAny*)args)[1].v_ptr)); + void* hc_scale = ((hc_scale_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[2].v_ptr) + 24)) : (((TVMFFIAny*)args)[2].v_ptr)); + void* hc_base = ((hc_base_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[3].v_ptr) + 24)) : (((TVMFFIAny*)args)[3].v_ptr)); + void* residual = ((residual_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[4].v_ptr) + 24)) : (((TVMFFIAny*)args)[4].v_ptr)); + void* post_mix = ((post_mix_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[5].v_ptr) + 24)) : (((TVMFFIAny*)args)[5].v_ptr)); + void* comb_mix = ((comb_mix_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[6].v_ptr) + 24)) : (((TVMFFIAny*)args)[6].v_ptr)); + void* layer_input = ((layer_input_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[7].v_ptr) + 24)) : (((TVMFFIAny*)args)[7].v_ptr)); + void* norm_weight = ((norm_weight_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[8].v_ptr) + 24)) : (((TVMFFIAny*)args)[8].v_ptr)); + bool mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_is_null = (gemm_out_mul == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.gemm_out_mul is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_is_null = (gemm_out_sqrsum == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.gemm_out_sqrsum is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_hc_scale_is_null = (hc_scale == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_hc_scale_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.hc_scale is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_hc_base_is_null = (hc_base == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_hc_base_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.hc_base is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_residual_is_null = (residual == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_residual_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.residual is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_post_mix_is_null = (post_mix == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_post_mix_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.post_mix is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_comb_mix_is_null = (comb_mix == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_comb_mix_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.comb_mix is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_layer_input_is_null = (layer_input == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_layer_input_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.layer_input is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_norm_weight_is_null = (norm_weight == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_norm_weight_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.norm_weight is expected to have non-NULL pointer"); + return -1; + } + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape = (((DLTensor*)gemm_out_mul)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape = (((DLTensor*)gemm_out_sqrsum)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_hc_scale_shape = (((DLTensor*)hc_scale)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_hc_base_shape = (((DLTensor*)hc_base)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_residual_shape = (((DLTensor*)residual)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape = (((DLTensor*)post_mix)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape = (((DLTensor*)comb_mix)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape = (((DLTensor*)layer_input)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_norm_weight_shape = (((DLTensor*)norm_weight)[0].shape); + if ((((DLTensor*)gemm_out_mul)[0].ndim) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_1; + result_1.type_index = kTVMFFINone; + result_1.zero_padding = 0; + result_1.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_1) != 0) { + return -1; + } + } + if (!((bool)1)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "Symbolic shape variable num_tokens requires at least one non-null buffer among: mhc_pre_big_fuse_with_norm_tilelang.gemm_out_mul, mhc_pre_big_fuse_with_norm_tilelang.gemm_out_sqrsum, mhc_pre_big_fuse_with_norm_tilelang.residual, mhc_pre_big_fuse_with_norm_tilelang.post_mix, mhc_pre_big_fuse_with_norm_tilelang.comb_mix, mhc_pre_big_fuse_with_norm_tilelang.layer_input"); + return -1; + } + int32_t num_tokens = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]); + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides = (((DLTensor*)gemm_out_mul)[0].strides); + int32_t dev_id = (((DLTensor*)gemm_out_mul)[0].device.device_id); + void* gemm_out_mul_1 = (((DLTensor*)gemm_out_mul)[0].data); + if ((((DLTensor*)gemm_out_sqrsum)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_2; + result_2.type_index = kTVMFFINone; + result_2.zero_padding = 0; + result_2.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_2) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides = (((DLTensor*)gemm_out_sqrsum)[0].strides); + void* gemm_out_sqrsum_1 = (((DLTensor*)gemm_out_sqrsum)[0].data); + if ((((DLTensor*)hc_scale)[0].ndim) != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_3; + result_3.type_index = kTVMFFINone; + result_3.zero_padding = 0; + result_3.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_3) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides = (((DLTensor*)hc_scale)[0].strides); + void* hc_scale_1 = (((DLTensor*)hc_scale)[0].data); + if ((((DLTensor*)hc_base)[0].ndim) != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_4; + result_4.type_index = kTVMFFINone; + result_4.zero_padding = 0; + result_4.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_4) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides = (((DLTensor*)hc_base)[0].strides); + void* hc_base_1 = (((DLTensor*)hc_base)[0].data); + if ((((DLTensor*)residual)[0].ndim) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_5; + result_5.type_index = kTVMFFINone; + result_5.zero_padding = 0; + result_5.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_5) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_residual_strides = (((DLTensor*)residual)[0].strides); + void* residual_1 = (((DLTensor*)residual)[0].data); + if ((((DLTensor*)post_mix)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_6; + result_6.type_index = kTVMFFINone; + result_6.zero_padding = 0; + result_6.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_6) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides = (((DLTensor*)post_mix)[0].strides); + void* post_mix_1 = (((DLTensor*)post_mix)[0].data); + if ((((DLTensor*)comb_mix)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_7; + result_7.type_index = kTVMFFINone; + result_7.zero_padding = 0; + result_7.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_7) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides = (((DLTensor*)comb_mix)[0].strides); + void* comb_mix_1 = (((DLTensor*)comb_mix)[0].data); + if ((((DLTensor*)layer_input)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_8; + result_8.type_index = kTVMFFINone; + result_8.zero_padding = 0; + result_8.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_8) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides = (((DLTensor*)layer_input)[0].strides); + void* layer_input_1 = (((DLTensor*)layer_input)[0].data); + if ((((DLTensor*)norm_weight)[0].ndim) != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_9; + result_9.type_index = kTVMFFINone; + result_9.zero_padding = 0; + result_9.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_9) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides = (((DLTensor*)norm_weight)[0].strides); + void* norm_weight_1 = (((DLTensor*)norm_weight)[0].data); + if ((((((DLTensor*)gemm_out_mul)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)gemm_out_mul)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)gemm_out_mul)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_10; + result_10.type_index = kTVMFFINone; + result_10.zero_padding = 0; + result_10.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_10) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[0]) != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_11; + result_11.type_index = kTVMFFINone; + result_11.zero_padding = 0; + result_11.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_11) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[2]) != 24) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)24; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[2])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_12; + result_12.type_index = kTVMFFINone; + result_12.zero_padding = 0; + result_12.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_12) != 0) { + return -1; + } + } + int32_t condval; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval = 1; + } else { + condval = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[2]); + } + if (condval != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_1; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval_1 = 1; + } else { + condval_1 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[2]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_1); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_13; + result_13.type_index = kTVMFFINone; + result_13.zero_padding = 0; + result_13.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_13) != 0) { + return -1; + } + } + int32_t condval_2; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval_2 = 1; + } else { + condval_2 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[1]); + } + if ((condval_2 != 24) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_14; + result_14.type_index = kTVMFFINone; + result_14.zero_padding = 0; + result_14.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_14) != 0) { + return -1; + } + } + int32_t condval_3; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval_3 = 1; + } else { + condval_3 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[0]); + } + if (((num_tokens * 24) != condval_3) && (num_tokens != 0)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_15; + result_15.type_index = kTVMFFINone; + result_15.zero_padding = 0; + result_15.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_15) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)gemm_out_mul)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_16; + result_16.type_index = kTVMFFINone; + result_16.zero_padding = 0; + result_16.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_16) != 0) { + return -1; + } + } + if ((((DLTensor*)gemm_out_mul)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_17; + result_17.type_index = kTVMFFINone; + result_17.zero_padding = 0; + result_17.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_17) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (gemm_out_mul_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_18; + result_18.type_index = kTVMFFINone; + result_18.zero_padding = 0; + result_18.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_18) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)gemm_out_sqrsum)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)gemm_out_sqrsum)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)gemm_out_sqrsum)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_19; + result_19.type_index = kTVMFFINone; + result_19.zero_padding = 0; + result_19.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_19) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[0]) != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_20; + result_20.type_index = kTVMFFINone; + result_20.zero_padding = 0; + result_20.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_20) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[1])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_21; + result_21.type_index = kTVMFFINone; + result_21.zero_padding = 0; + result_21.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_21) != 0) { + return -1; + } + } + int32_t condval_4; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides == NULL)) { + condval_4 = 1; + } else { + condval_4 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides)[1]); + } + if ((condval_4 != 1) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_22; + result_22.type_index = kTVMFFINone; + result_22.zero_padding = 0; + result_22.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_22) != 0) { + return -1; + } + } + int32_t condval_5; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides == NULL)) { + condval_5 = 1; + } else { + condval_5 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides)[0]); + } + if ((((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != condval_5) && (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != 0)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_23; + result_23.type_index = kTVMFFINone; + result_23.zero_padding = 0; + result_23.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_23) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)gemm_out_sqrsum)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_24; + result_24.type_index = kTVMFFINone; + result_24.zero_padding = 0; + result_24.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_24) != 0) { + return -1; + } + } + if ((((DLTensor*)gemm_out_sqrsum)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_25; + result_25.type_index = kTVMFFINone; + result_25.zero_padding = 0; + result_25.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_25) != 0) { + return -1; + } + } + if ((((DLTensor*)gemm_out_sqrsum)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_26; + result_26.type_index = kTVMFFINone; + result_26.zero_padding = 0; + result_26.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_26) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (gemm_out_sqrsum_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_27; + result_27.type_index = kTVMFFINone; + result_27.zero_padding = 0; + result_27.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_27) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)hc_scale)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)hc_scale)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)hc_scale)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_28; + result_28.type_index = kTVMFFINone; + result_28.zero_padding = 0; + result_28.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_28) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_shape)[0]) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_29; + result_29.type_index = kTVMFFINone; + result_29.zero_padding = 0; + result_29.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_29) != 0) { + return -1; + } + } + int32_t condval_6; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides == NULL)) { + condval_6 = 1; + } else { + condval_6 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides)[0]); + } + if (condval_6 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_7; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides == NULL)) { + condval_7 = 1; + } else { + condval_7 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides)[0]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_7); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_30; + result_30.type_index = kTVMFFINone; + result_30.zero_padding = 0; + result_30.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_30) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)hc_scale)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_31; + result_31.type_index = kTVMFFINone; + result_31.zero_padding = 0; + result_31.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_31) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_scale)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_32; + result_32.type_index = kTVMFFINone; + result_32.zero_padding = 0; + result_32.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_32) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_scale)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_33; + result_33.type_index = kTVMFFINone; + result_33.zero_padding = 0; + result_33.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_33) != 0) { + return -1; + } + } + if (hc_scale_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_34; + result_34.type_index = kTVMFFINone; + result_34.zero_padding = 0; + result_34.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_34) != 0) { + return -1; + } + } + if ((((((DLTensor*)hc_base)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)hc_base)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)hc_base)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_35; + result_35.type_index = kTVMFFINone; + result_35.zero_padding = 0; + result_35.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_35) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_shape)[0]) != 24) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)24; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_36; + result_36.type_index = kTVMFFINone; + result_36.zero_padding = 0; + result_36.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_36) != 0) { + return -1; + } + } + int32_t condval_8; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides == NULL)) { + condval_8 = 1; + } else { + condval_8 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides)[0]); + } + if (condval_8 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_9; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides == NULL)) { + condval_9 = 1; + } else { + condval_9 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides)[0]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_9); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_37; + result_37.type_index = kTVMFFINone; + result_37.zero_padding = 0; + result_37.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_37) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)hc_base)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_38; + result_38.type_index = kTVMFFINone; + result_38.zero_padding = 0; + result_38.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_38) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_base)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_39; + result_39.type_index = kTVMFFINone; + result_39.zero_padding = 0; + result_39.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_39) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_base)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_40; + result_40.type_index = kTVMFFINone; + result_40.zero_padding = 0; + result_40.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_40) != 0) { + return -1; + } + } + if (hc_base_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_41; + result_41.type_index = kTVMFFINone; + result_41.zero_padding = 0; + result_41.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_41) != 0) { + return -1; + } + } + if ((((((DLTensor*)residual)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)residual)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)residual)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)residual)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)residual)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_42; + result_42.type_index = kTVMFFINone; + result_42.zero_padding = 0; + result_42.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_42) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_43; + result_43.type_index = kTVMFFINone; + result_43.zero_padding = 0; + result_43.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_43) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[1]) != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_44; + result_44.type_index = kTVMFFINone; + result_44.zero_padding = 0; + result_44.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_44) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[2]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[2])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_45; + result_45.type_index = kTVMFFINone; + result_45.zero_padding = 0; + result_45.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_45) != 0) { + return -1; + } + } + int32_t condval_10; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_10 = 1; + } else { + condval_10 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[2]); + } + if (condval_10 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_11; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_11 = 1; + } else { + condval_11 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[2]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_11); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_46; + result_46.type_index = kTVMFFINone; + result_46.zero_padding = 0; + result_46.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_46) != 0) { + return -1; + } + } + int32_t condval_12; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_12 = 1; + } else { + condval_12 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[1]); + } + if (condval_12 != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_13; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_13 = 1; + } else { + condval_13 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_13); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_47; + result_47.type_index = kTVMFFINone; + result_47.zero_padding = 0; + result_47.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_47) != 0) { + return -1; + } + } + int32_t condval_14; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_14 = 1; + } else { + condval_14 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[0]); + } + if ((condval_14 != 16384) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_48; + result_48.type_index = kTVMFFINone; + result_48.zero_padding = 0; + result_48.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_48) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)residual)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_49; + result_49.type_index = kTVMFFINone; + result_49.zero_padding = 0; + result_49.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_49) != 0) { + return -1; + } + } + if ((((DLTensor*)residual)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)residual)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_50; + result_50.type_index = kTVMFFINone; + result_50.zero_padding = 0; + result_50.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_50) != 0) { + return -1; + } + } + if ((((DLTensor*)residual)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_51; + result_51.type_index = kTVMFFINone; + result_51.zero_padding = 0; + result_51.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_51) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (residual_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_52; + result_52.type_index = kTVMFFINone; + result_52.zero_padding = 0; + result_52.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_52) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)post_mix)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)post_mix)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)post_mix)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_53; + result_53.type_index = kTVMFFINone; + result_53.zero_padding = 0; + result_53.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_53) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_54; + result_54.type_index = kTVMFFINone; + result_54.zero_padding = 0; + result_54.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_54) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[1]) != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_55; + result_55.type_index = kTVMFFINone; + result_55.zero_padding = 0; + result_55.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_55) != 0) { + return -1; + } + } + int32_t condval_15; + if ((mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides == NULL)) { + condval_15 = 1; + } else { + condval_15 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides)[1]); + } + if (condval_15 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_16; + if ((mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides == NULL)) { + condval_16 = 1; + } else { + condval_16 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_16); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_56; + result_56.type_index = kTVMFFINone; + result_56.zero_padding = 0; + result_56.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_56) != 0) { + return -1; + } + } + int32_t condval_17; + if ((mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides == NULL)) { + condval_17 = 1; + } else { + condval_17 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides)[0]); + } + if ((condval_17 != 4) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_57; + result_57.type_index = kTVMFFINone; + result_57.zero_padding = 0; + result_57.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_57) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)post_mix)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_58; + result_58.type_index = kTVMFFINone; + result_58.zero_padding = 0; + result_58.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_58) != 0) { + return -1; + } + } + if ((((DLTensor*)post_mix)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_59; + result_59.type_index = kTVMFFINone; + result_59.zero_padding = 0; + result_59.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_59) != 0) { + return -1; + } + } + if ((((DLTensor*)post_mix)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_60; + result_60.type_index = kTVMFFINone; + result_60.zero_padding = 0; + result_60.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_60) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (post_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_61; + result_61.type_index = kTVMFFINone; + result_61.zero_padding = 0; + result_61.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_61) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)comb_mix)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)comb_mix)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)comb_mix)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_62; + result_62.type_index = kTVMFFINone; + result_62.zero_padding = 0; + result_62.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_62) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_63; + result_63.type_index = kTVMFFINone; + result_63.zero_padding = 0; + result_63.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_63) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[1]) != 16) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_64; + result_64.type_index = kTVMFFINone; + result_64.zero_padding = 0; + result_64.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_64) != 0) { + return -1; + } + } + int32_t condval_18; + if ((mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides == NULL)) { + condval_18 = 1; + } else { + condval_18 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides)[1]); + } + if (condval_18 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_19; + if ((mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides == NULL)) { + condval_19 = 1; + } else { + condval_19 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_19); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_65; + result_65.type_index = kTVMFFINone; + result_65.zero_padding = 0; + result_65.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_65) != 0) { + return -1; + } + } + int32_t condval_20; + if ((mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides == NULL)) { + condval_20 = 1; + } else { + condval_20 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides)[0]); + } + if ((condval_20 != 16) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_66; + result_66.type_index = kTVMFFINone; + result_66.zero_padding = 0; + result_66.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_66) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)comb_mix)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_67; + result_67.type_index = kTVMFFINone; + result_67.zero_padding = 0; + result_67.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_67) != 0) { + return -1; + } + } + if ((((DLTensor*)comb_mix)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_68; + result_68.type_index = kTVMFFINone; + result_68.zero_padding = 0; + result_68.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_68) != 0) { + return -1; + } + } + if ((((DLTensor*)comb_mix)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_69; + result_69.type_index = kTVMFFINone; + result_69.zero_padding = 0; + result_69.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_69) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (comb_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_70; + result_70.type_index = kTVMFFINone; + result_70.zero_padding = 0; + result_70.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_70) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)layer_input)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)layer_input)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)layer_input)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_71; + result_71.type_index = kTVMFFINone; + result_71.zero_padding = 0; + result_71.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_71) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_72; + result_72.type_index = kTVMFFINone; + result_72.zero_padding = 0; + result_72.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_72) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[1]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_73; + result_73.type_index = kTVMFFINone; + result_73.zero_padding = 0; + result_73.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_73) != 0) { + return -1; + } + } + int32_t condval_21; + if ((mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides == NULL)) { + condval_21 = 1; + } else { + condval_21 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides)[1]); + } + if (condval_21 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_22; + if ((mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides == NULL)) { + condval_22 = 1; + } else { + condval_22 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_22); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_74; + result_74.type_index = kTVMFFINone; + result_74.zero_padding = 0; + result_74.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_74) != 0) { + return -1; + } + } + int32_t condval_23; + if ((mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides == NULL)) { + condval_23 = 1; + } else { + condval_23 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides)[0]); + } + if ((condval_23 != 4096) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_75; + result_75.type_index = kTVMFFINone; + result_75.zero_padding = 0; + result_75.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_75) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)layer_input)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_76; + result_76.type_index = kTVMFFINone; + result_76.zero_padding = 0; + result_76.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_76) != 0) { + return -1; + } + } + if ((((DLTensor*)layer_input)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_77; + result_77.type_index = kTVMFFINone; + result_77.zero_padding = 0; + result_77.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_77) != 0) { + return -1; + } + } + if ((((DLTensor*)layer_input)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_78; + result_78.type_index = kTVMFFINone; + result_78.zero_padding = 0; + result_78.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_78) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (layer_input_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_79; + result_79.type_index = kTVMFFINone; + result_79.zero_padding = 0; + result_79.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_79) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)norm_weight)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)norm_weight)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)norm_weight)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_80; + result_80.type_index = kTVMFFINone; + result_80.zero_padding = 0; + result_80.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_80) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_shape)[0]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_81; + result_81.type_index = kTVMFFINone; + result_81.zero_padding = 0; + result_81.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_81) != 0) { + return -1; + } + } + int32_t condval_24; + if ((mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides == NULL)) { + condval_24 = 1; + } else { + condval_24 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides)[0]); + } + if (condval_24 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_25; + if ((mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides == NULL)) { + condval_25 = 1; + } else { + condval_25 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides)[0]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_25); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_82; + result_82.type_index = kTVMFFINone; + result_82.zero_padding = 0; + result_82.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_82) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)norm_weight)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_83; + result_83.type_index = kTVMFFINone; + result_83.zero_padding = 0; + result_83.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_83) != 0) { + return -1; + } + } + if ((((DLTensor*)norm_weight)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_84; + result_84.type_index = kTVMFFINone; + result_84.zero_padding = 0; + result_84.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_84) != 0) { + return -1; + } + } + if ((((DLTensor*)norm_weight)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_85; + result_85.type_index = kTVMFFINone; + result_85.zero_padding = 0; + result_85.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_85) != 0) { + return -1; + } + } + if (norm_weight_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_86; + result_86.type_index = kTVMFFINone; + result_86.zero_padding = 0; + result_86.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_86) != 0) { + return -1; + } + } + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = ((int64_t)2); + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = ((int64_t)dev_id); + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + if (__tvm_set_device_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_set_device", &__tvm_set_device_packed) != 0) { + return -1; + } + } + TVMFFIAny result_87; + result_87.type_index = kTVMFFINone; + result_87.zero_padding = 0; + result_87.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_set_device_packed, (TVMFFIAny*) stack_ffi_any, 2, &result_87) != 0) { + return -1; + } + if (comb_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = comb_mix_1; + if (gemm_out_mul_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = gemm_out_mul_1; + if (gemm_out_sqrsum_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = gemm_out_sqrsum_1; + if (hc_base_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_ptr) = hc_base_1; + if (hc_scale_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_ptr) = hc_scale_1; + if (layer_input_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_ptr) = layer_input_1; + if (norm_weight_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_ptr) = norm_weight_1; + if (post_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_ptr) = post_mix_1; + if (residual_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_ptr) = residual_1; + (((TVMFFIAny*)stack_ffi_any)[9].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[9].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[9].v_int64) = ((int64_t)num_tokens); + (((TVMFFIAny*)stack_ffi_any)[10].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[10].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[10].v_int64) = ((int64_t)num_tokens); + (((TVMFFIAny*)stack_ffi_any)[11].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[11].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[11].v_int64) = ((int64_t)96); + (((TVMFFIAny*)stack_ffi_any)[12].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[12].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[12].v_int64) = ((int64_t)1); + (((TVMFFIAny*)stack_ffi_any)[13].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[13].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[13].v_int64) = ((int64_t)1); + (((TVMFFIAny*)stack_ffi_any)[14].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[14].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[14].v_int64) = ((int64_t)29040); + (((TVMFFIAny*)stack_ffi_any)[15].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[15].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[15].v_int64) = (int64_t)0; + if (mhc_pre_big_fuse_with_norm_tilelang_kernel_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "mhc_pre_big_fuse_with_norm_tilelang_kernel", &mhc_pre_big_fuse_with_norm_tilelang_kernel_packed) != 0) { + return -1; + } + } + TVMFFIAny result_88; + result_88.type_index = kTVMFFINone; + result_88.zero_padding = 0; + result_88.v_int64 = 0; + if (TVMFFIFunctionCall(mhc_pre_big_fuse_with_norm_tilelang_kernel_packed, (TVMFFIAny*) stack_ffi_any, 15, &result_88) != 0) { + return -1; + } + return 0; +} + +// CodegenC: NOTE: Auto-generated entry function +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_main(void* self, void* args,int num_args, void* result) { + return __tvm_ffi_mhc_pre_big_fuse_with_norm_tilelang(self, args, num_args, result); +} diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/47c189497f8ff487a170b06db17717920a83856d30485b87094ce9d42596885b/params.pkl b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/47c189497f8ff487a170b06db17717920a83856d30485b87094ce9d42596885b/params.pkl new file mode 100644 index 0000000..14a52c9 Binary files /dev/null and b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/47c189497f8ff487a170b06db17717920a83856d30485b87094ce9d42596885b/params.pkl differ diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/596345ac7ba68225bdd1b9b6abe5e4fbb63f7c57ec2523668ca14b62460b457a/device_kernel.cu b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/596345ac7ba68225bdd1b9b6abe5e4fbb63f7c57ec2523668ca14b62460b457a/device_kernel.cu new file mode 100644 index 0000000..ee7574e --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/596345ac7ba68225bdd1b9b6abe5e4fbb63f7c57ec2523668ca14b62460b457a/device_kernel.cu @@ -0,0 +1,424 @@ +#include +#include +#include +#include +#include +#include +#include +#ifdef ENABLE_BF16 +#include +#endif + +extern "C" __global__ void mhc_pre_big_fuse_with_norm_tilelang_kernel(float* comb_mix, const float* gemm_out_mul, const float* gemm_out_sqrsum, const float* hc_base, const float* hc_scale, bfloat16_t* layer_input, const bfloat16_t* norm_weight, float* post_mix, const bfloat16_t* residual, int num_tokens); +extern "C" __global__ void __launch_bounds__(96, 1) mhc_pre_big_fuse_with_norm_tilelang_kernel(float* comb_mix, const float* gemm_out_mul, const float* gemm_out_sqrsum, const float* hc_base, const float* hc_scale, bfloat16_t* layer_input, const bfloat16_t* norm_weight, float* post_mix, const bfloat16_t* residual, int num_tokens) { + extern __shared__ __align__(1024) uchar buf_dyn_shmem[]; + float mixes[1]; + float rms[1]; + float cm[1]; + float row_max[1]; + float row_sum[1]; + float col_sum[1]; + float sumsq_per_pos[16]; + float sumsq[1]; + float rsqrt_norm[1]; + float xl[64]; + float ol[16]; + bfloat16_t xs_local_cast[8]; + bfloat16_t xs_local_cast_1[8]; + bfloat16_t xs_local_cast_2[8]; + float w_local[16]; + float ol_1[16]; + bfloat16_t w_shared_local_cast_3[8]; + bfloat16_t output_shared_local_cast_4[8]; + bfloat16_t layer_input_local_cast_5[8]; + bfloat16_t w_shared_local_cast_6[8]; + bfloat16_t output_shared_local_cast_7[8]; + bfloat16_t layer_input_local_cast_8[8]; + bfloat16_t w_shared_local_cast_9[8]; + bfloat16_t output_shared_local_cast_10[8]; + bfloat16_t layer_input_local_cast_11[8]; + mixes[0] = 0x0p+0f/*0.000000e+00*/; + rms[0] = 0x0p+0f/*0.000000e+00*/; + cudaGridDependencySynchronize(); + for (int i_split = 0; i_split < 2; ++i_split) { + rms[0] = (rms[0] + gemm_out_sqrsum[((((int64_t)i_split) * ((int64_t)num_tokens)) + ((int64_t)((int)blockIdx.x)))]); + } + rms[0] = rsqrtf(((rms[0] / 0x1p+14f/*1.638400e+04*/) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + mixes[0] = 0x0p+0f/*0.000000e+00*/; + for (int i_split_1 = 0; i_split_1 < 2; ++i_split_1) { + mixes[0] = (mixes[0] + gemm_out_mul[(((((int64_t)((int)blockIdx.x)) * (int64_t)24) + ((((int64_t)i_split_1) * ((int64_t)num_tokens)) * (int64_t)24)) + (((int64_t)((int)threadIdx.x)) % (int64_t)24))]); + } + mixes[0] = (mixes[0] * rms[0]); + if ((((int)threadIdx.x) / 24) == 0) { + ((float*)buf_dyn_shmem)[(((int)threadIdx.x) % 24)] = mixes[0]; + } + __syncthreads(); + if (((int)threadIdx.x) < 32) { + if (((int)threadIdx.x) < 4) { + post_mix[((((int64_t)((int)blockIdx.x)) * (int64_t)4) + ((int64_t)((int)threadIdx.x)))] = ((0x1p+0f/*1.000000e+00*/ / (0x1p+0f/*1.000000e+00*/ + expf((0x0p+0f/*0.000000e+00*/ - ((((float*)buf_dyn_shmem)[(((int)threadIdx.x) + 4)] * hc_scale[1]) + hc_base[(((int)threadIdx.x) + 4)]))))) * 0x1p+1f/*2.000000e+00*/); + } + cm[0] = ((((float*)buf_dyn_shmem)[((((int)threadIdx.x) & 15) + 8)] * hc_scale[2]) + hc_base[((((int)threadIdx.x) & 15) + 8)]); + row_max[0] = -CUDART_INF_F; + row_max[0] = max(row_max[0], cm[0]); + row_max[0] = tl::AllReduce>::run(row_max[0]); + cm[0] = expf((cm[0] - row_max[0])); + row_sum[0] = 0x0p+0f/*0.000000e+00*/; + row_sum[0] = (row_sum[0] + cm[0]); + row_sum[0] = tl::AllReduce>::run(row_sum[0]); + cm[0] = ((cm[0] / row_sum[0]) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/); + col_sum[0] = 0x0p+0f/*0.000000e+00*/; + col_sum[0] = (col_sum[0] + cm[0]); + col_sum[0] = tl::AllReduce>::run(col_sum[0]); + cm[0] = (cm[0] / (col_sum[0] + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + for (int __1 = 0; __1 < 19; ++__1) { + row_sum[0] = 0x0p+0f/*0.000000e+00*/; + row_sum[0] = (row_sum[0] + cm[0]); + row_sum[0] = tl::AllReduce>::run(row_sum[0]); + cm[0] = (cm[0] / (row_sum[0] + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + col_sum[0] = 0x0p+0f/*0.000000e+00*/; + col_sum[0] = (col_sum[0] + cm[0]); + col_sum[0] = tl::AllReduce>::run(col_sum[0]); + cm[0] = (cm[0] / (col_sum[0] + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + } + if ((((int)threadIdx.x) >> 4) == 0) { + comb_mix[((((int64_t)((int)blockIdx.x)) * (int64_t)16) + (((int64_t)((int)threadIdx.x)) & (int64_t)15))] = cm[0]; + } + } else { + if (((int)threadIdx.x) < 36) { + ((float*)buf_dyn_shmem)[(((int)threadIdx.x) + 7224)] = ((0x1p+0f/*1.000000e+00*/ / (0x1p+0f/*1.000000e+00*/ + expf((0x0p+0f/*0.000000e+00*/ - ((((float*)buf_dyn_shmem)[(((int)threadIdx.x) - 32)] * hc_scale[0]) + hc_base[(((int)threadIdx.x) - 32)]))))) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/); + } + #pragma unroll + for (int i = 0; i < 4; ++i) { + float broadcast_var = 0x0p+0f/*0.000000e+00*/; + *(float4*)(sumsq_per_pos + (i * 4)) = make_float4(broadcast_var, broadcast_var, broadcast_var, broadcast_var); + } + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_1 = 0; i_1 < 8; ++i_1) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i_1 >> 1) * 1024) + (((((i_1 * 64) + ((int)threadIdx.x)) + 96) & 127) * 8)) + 48)])), (&(residual[(((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + ((((int64_t)i_1) >> (int64_t)1) * (int64_t)4096)) + (((((((int64_t)i_1) * (int64_t)64) + ((int64_t)((int)threadIdx.x))) + (int64_t)96) & (int64_t)127) * (int64_t)8))]))); + } + tl::cp_async_commit(); + #pragma unroll + for (int i_2 = 0; i_2 < 8; ++i_2) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i_2 >> 1) * 1024) + (((((i_2 * 64) + ((int)threadIdx.x)) + 96) & 127) * 8)) + 4144)])), (&(residual[((((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + ((((int64_t)i_2) >> (int64_t)1) * (int64_t)4096)) + (((((((int64_t)i_2) * (int64_t)64) + ((int64_t)((int)threadIdx.x))) + (int64_t)96) & (int64_t)127) * (int64_t)8)) + (int64_t)1024)]))); + } + tl::cp_async_commit(); + for (int i0_h = 0; i0_h < 2; ++i0_h) { + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_3 = 0; i_3 < 8; ++i_3) { + *(uint4*)(xs_local_cast + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + ((((i0_h * 4096) + (i_3 * 512)) + (((int)threadIdx.x) * 8)) - 208)); + for (int vec = 0; vec < 2; ++vec) { + float4 __2; + uint2 v_ = *(uint2*)(xs_local_cast + (vec * 4)); + ((float2*)(&__2))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v_))[0]); + ((float2*)(&__2))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v_))[1]); + *(float4*)(xl + ((i_3 * 8) + (vec * 4))) = __2; + } + } + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_4 = 0; i_4 < 8; ++i_4) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i0_h * 4096) + ((i_4 >> 1) * 1024)) + (((((i_4 * 64) + ((int)threadIdx.x)) + 96) & 127) * 8)) + 48)])), (&(residual[(((((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + ((((int64_t)i_4) >> (int64_t)1) * (int64_t)4096)) + (((int64_t)i0_h) * (int64_t)1024)) + (((((((int64_t)i_4) * (int64_t)64) + ((int64_t)((int)threadIdx.x))) + (int64_t)96) & (int64_t)127) * (int64_t)8)) + (int64_t)2048)]))); + } + tl::cp_async_commit(); + #pragma unroll + for (int i_5 = 0; i_5 < 4; ++i_5) { + float broadcast_var_1 = 0x0p+0f/*0.000000e+00*/; + *(float4*)(ol + (i_5 * 4)) = make_float4(broadcast_var_1, broadcast_var_1, broadcast_var_1, broadcast_var_1); + } + tl::__sync_thread_partial<3, 64>(); + for (int i_hc = 0; i_hc < 4; ++i_hc) { + float pre = ((float*)buf_dyn_shmem)[(i_hc + 7256)]; + #pragma unroll + for (int i_6 = 0; i_6 < 16; ++i_6) { + ol[i_6] = (ol[i_6] + (pre * xl[((i_hc * 16) + i_6)])); + } + } + #pragma unroll + for (int i_7 = 0; i_7 < 4; ++i_7) { + float4 __3; + float4 v__1 = *(float4*)(sumsq_per_pos + (i_7 * 4)); + float4 __4; + float4 v__2 = *(float4*)(ol + (i_7 * 4)); + __4.x = (v__2.x*v__2.x); + __4.y = (v__2.y*v__2.y); + __4.z = (v__2.z*v__2.z); + __4.w = (v__2.w*v__2.w); + __3.x = (v__1.x+__4.x); + __3.y = (v__1.y+__4.y); + __3.z = (v__1.z+__4.z); + __3.w = (v__1.w+__4.w); + *(float4*)(sumsq_per_pos + (i_7 * 4)) = __3; + uint2 __5; + float4 v__3 = *(float4*)(ol + (i_7 * 4)); + (reinterpret_cast<__nv_bfloat162*>(&__5))[0] = __float22bfloat162_rn(((float2*)(&v__3))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__5))[1] = __float22bfloat162_rn(((float2*)(&v__3))[1]); + *(uint2*)(((bfloat16_t*)buf_dyn_shmem) + (((((i0_h * 1024) + ((i_7 >> 1) * 512)) + (((int)threadIdx.x) * 8)) + ((i_7 & 1) * 4)) + 7984)) = __5; + } + } + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_8 = 0; i_8 < 8; ++i_8) { + *(uint4*)(xs_local_cast_1 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_8 * 512) + (((int)threadIdx.x) * 8)) - 208)); + for (int vec_1 = 0; vec_1 < 2; ++vec_1) { + float4 __6; + uint2 v__4 = *(uint2*)(xs_local_cast_1 + (vec_1 * 4)); + ((float2*)(&__6))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__4))[0]); + ((float2*)(&__6))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__4))[1]); + *(float4*)(xl + ((i_8 * 8) + (vec_1 * 4))) = __6; + } + } + #pragma unroll + for (int i_9 = 0; i_9 < 4; ++i_9) { + float broadcast_var_2 = 0x0p+0f/*0.000000e+00*/; + *(float4*)(ol + (i_9 * 4)) = make_float4(broadcast_var_2, broadcast_var_2, broadcast_var_2, broadcast_var_2); + } + for (int i_hc_1 = 0; i_hc_1 < 4; ++i_hc_1) { + float pre_1 = ((float*)buf_dyn_shmem)[(i_hc_1 + 7256)]; + #pragma unroll + for (int i_10 = 0; i_10 < 16; ++i_10) { + ol[i_10] = (ol[i_10] + (pre_1 * xl[((i_hc_1 * 16) + i_10)])); + } + } + #pragma unroll + for (int i_11 = 0; i_11 < 4; ++i_11) { + float4 __7; + float4 v__5 = *(float4*)(sumsq_per_pos + (i_11 * 4)); + float4 __8; + float4 v__6 = *(float4*)(ol + (i_11 * 4)); + __8.x = (v__6.x*v__6.x); + __8.y = (v__6.y*v__6.y); + __8.z = (v__6.z*v__6.z); + __8.w = (v__6.w*v__6.w); + __7.x = (v__5.x+__8.x); + __7.y = (v__5.y+__8.y); + __7.z = (v__5.z+__8.z); + __7.w = (v__5.w+__8.w); + *(float4*)(sumsq_per_pos + (i_11 * 4)) = __7; + uint2 __9; + float4 v__7 = *(float4*)(ol + (i_11 * 4)); + (reinterpret_cast<__nv_bfloat162*>(&__9))[0] = __float22bfloat162_rn(((float2*)(&v__7))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__9))[1] = __float22bfloat162_rn(((float2*)(&v__7))[1]); + *(uint2*)(((bfloat16_t*)buf_dyn_shmem) + (((((i_11 >> 1) * 512) + (((int)threadIdx.x) * 8)) + ((i_11 & 1) * 4)) + 10032)) = __9; + } + tl::cp_async_wait<0>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_12 = 0; i_12 < 8; ++i_12) { + *(uint4*)(xs_local_cast_2 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_12 * 512) + (((int)threadIdx.x) * 8)) + 3888)); + for (int vec_2 = 0; vec_2 < 2; ++vec_2) { + float4 __10; + uint2 v__8 = *(uint2*)(xs_local_cast_2 + (vec_2 * 4)); + ((float2*)(&__10))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__8))[0]); + ((float2*)(&__10))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__8))[1]); + *(float4*)(xl + ((i_12 * 8) + (vec_2 * 4))) = __10; + } + } + #pragma unroll + for (int i_13 = 0; i_13 < 4; ++i_13) { + float broadcast_var_3 = 0x0p+0f/*0.000000e+00*/; + *(float4*)(ol + (i_13 * 4)) = make_float4(broadcast_var_3, broadcast_var_3, broadcast_var_3, broadcast_var_3); + } + for (int i_hc_2 = 0; i_hc_2 < 4; ++i_hc_2) { + float pre_2 = ((float*)buf_dyn_shmem)[(i_hc_2 + 7256)]; + #pragma unroll + for (int i_14 = 0; i_14 < 16; ++i_14) { + ol[i_14] = (ol[i_14] + (pre_2 * xl[((i_hc_2 * 16) + i_14)])); + } + } + #pragma unroll + for (int i_15 = 0; i_15 < 4; ++i_15) { + float4 __11; + float4 v__9 = *(float4*)(sumsq_per_pos + (i_15 * 4)); + float4 __12; + float4 v__10 = *(float4*)(ol + (i_15 * 4)); + __12.x = (v__10.x*v__10.x); + __12.y = (v__10.y*v__10.y); + __12.z = (v__10.z*v__10.z); + __12.w = (v__10.w*v__10.w); + __11.x = (v__9.x+__12.x); + __11.y = (v__9.y+__12.y); + __11.z = (v__9.z+__12.z); + __11.w = (v__9.w+__12.w); + *(float4*)(sumsq_per_pos + (i_15 * 4)) = __11; + uint2 __13; + float4 v__11 = *(float4*)(ol + (i_15 * 4)); + (reinterpret_cast<__nv_bfloat162*>(&__13))[0] = __float22bfloat162_rn(((float2*)(&v__11))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__13))[1] = __float22bfloat162_rn(((float2*)(&v__11))[1]); + *(uint2*)(((bfloat16_t*)buf_dyn_shmem) + (((((i_15 >> 1) * 512) + (((int)threadIdx.x) * 8)) + ((i_15 & 1) * 4)) + 11056)) = __13; + } + sumsq[0] = 0x0p+0f/*0.000000e+00*/; + #pragma unroll + for (int rv = 0; rv < 16; ++rv) { + sumsq[0] = (sumsq[0] + sumsq_per_pos[(((rv & 1) * 8) + (rv >> 1))]); + } + tl::__sync_thread_partial<3, 64>(); + sumsq[0] = tl::AllReduce>::run(sumsq[0], (&(((float*)buf_dyn_shmem)[7192]))); + rsqrt_norm[0] = rsqrtf(((sumsq[0] / 0x1p+12f/*4.096000e+03*/) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + #pragma unroll + for (int i_16 = 0; i_16 < 2; ++i_16) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[(((i_16 * 512) + (((int)threadIdx.x) * 8)) + 12080)])), (&(norm_weight[(((i_16 * 512) + (((int)threadIdx.x) * 8)) - 256)]))); + } + tl::cp_async_commit(); + #pragma unroll + for (int i_17 = 0; i_17 < 2; ++i_17) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[(((i_17 * 512) + (((int)threadIdx.x) * 8)) + 13104)])), (&(norm_weight[(((i_17 * 512) + (((int)threadIdx.x) * 8)) + 768)]))); + } + tl::cp_async_commit(); + for (int i0_h_1 = 0; i0_h_1 < 2; ++i0_h_1) { + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_18 = 0; i_18 < 2; ++i_18) { + *(uint4*)(w_shared_local_cast_3 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + ((((i0_h_1 * 1024) + (i_18 * 512)) + (((int)threadIdx.x) * 8)) + 12080)); + for (int vec_3 = 0; vec_3 < 2; ++vec_3) { + float4 __14; + uint2 v__12 = *(uint2*)(w_shared_local_cast_3 + (vec_3 * 4)); + ((float2*)(&__14))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__12))[0]); + ((float2*)(&__14))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__12))[1]); + *(float4*)(w_local + ((i_18 * 8) + (vec_3 * 4))) = __14; + } + } + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_19 = 0; i_19 < 2; ++i_19) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i0_h_1 * 1024) + (i_19 * 512)) + (((int)threadIdx.x) * 8)) + 12080)])), (&(norm_weight[((((i0_h_1 * 1024) + (i_19 * 512)) + (((int)threadIdx.x) * 8)) + 1792)]))); + } + tl::cp_async_commit(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_20 = 0; i_20 < 2; ++i_20) { + *(uint4*)(output_shared_local_cast_4 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + ((((i0_h_1 * 1024) + (i_20 * 512)) + (((int)threadIdx.x) * 8)) + 7984)); + for (int vec_4 = 0; vec_4 < 2; ++vec_4) { + float4 __15; + float4 __16; + float4 __17; + uint2 v__13 = *(uint2*)(output_shared_local_cast_4 + (vec_4 * 4)); + ((float2*)(&__17))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__13))[0]); + ((float2*)(&__17))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__13))[1]); + float4 v__14 = make_float4(rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0]); + __16.x = (__17.x*v__14.x); + __16.y = (__17.y*v__14.y); + __16.z = (__17.z*v__14.z); + __16.w = (__17.w*v__14.w); + float4 v__15 = *(float4*)(w_local + ((i_20 * 8) + (vec_4 * 4))); + __15.x = (__16.x*v__15.x); + __15.y = (__16.y*v__15.y); + __15.z = (__16.z*v__15.z); + __15.w = (__16.w*v__15.w); + *(float4*)(ol_1 + ((i_20 * 8) + (vec_4 * 4))) = __15; + } + } + #pragma unroll + for (int i_21 = 0; i_21 < 2; ++i_21) { + for (int vec_5 = 0; vec_5 < 2; ++vec_5) { + uint2 __18; + float4 v__16 = *(float4*)(ol_1 + ((i_21 * 8) + (vec_5 * 4))); + (reinterpret_cast<__nv_bfloat162*>(&__18))[0] = __float22bfloat162_rn(((float2*)(&v__16))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__18))[1] = __float22bfloat162_rn(((float2*)(&v__16))[1]); + *(uint2*)(layer_input_local_cast_5 + (vec_5 * 4)) = __18; + } + *(uint4*)(layer_input + (((((((int64_t)((int)blockIdx.x)) * (int64_t)4096) + (((int64_t)i0_h_1) * (int64_t)1024)) + (((int64_t)i_21) * (int64_t)512)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8)) - (int64_t)256)) = *(uint4*)(layer_input_local_cast_5 + 0); + } + } + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_22 = 0; i_22 < 2; ++i_22) { + *(uint4*)(w_shared_local_cast_6 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_22 * 512) + (((int)threadIdx.x) * 8)) + 12080)); + for (int vec_6 = 0; vec_6 < 2; ++vec_6) { + float4 __19; + uint2 v__17 = *(uint2*)(w_shared_local_cast_6 + (vec_6 * 4)); + ((float2*)(&__19))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__17))[0]); + ((float2*)(&__19))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__17))[1]); + *(float4*)(w_local + ((i_22 * 8) + (vec_6 * 4))) = __19; + } + } + #pragma unroll + for (int i_23 = 0; i_23 < 2; ++i_23) { + *(uint4*)(output_shared_local_cast_7 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_23 * 512) + (((int)threadIdx.x) * 8)) + 10032)); + for (int vec_7 = 0; vec_7 < 2; ++vec_7) { + float4 __20; + float4 __21; + float4 __22; + uint2 v__18 = *(uint2*)(output_shared_local_cast_7 + (vec_7 * 4)); + ((float2*)(&__22))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__18))[0]); + ((float2*)(&__22))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__18))[1]); + float4 v__19 = make_float4(rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0]); + __21.x = (__22.x*v__19.x); + __21.y = (__22.y*v__19.y); + __21.z = (__22.z*v__19.z); + __21.w = (__22.w*v__19.w); + float4 v__20 = *(float4*)(w_local + ((i_23 * 8) + (vec_7 * 4))); + __20.x = (__21.x*v__20.x); + __20.y = (__21.y*v__20.y); + __20.z = (__21.z*v__20.z); + __20.w = (__21.w*v__20.w); + *(float4*)(ol_1 + ((i_23 * 8) + (vec_7 * 4))) = __20; + } + } + #pragma unroll + for (int i_24 = 0; i_24 < 2; ++i_24) { + for (int vec_8 = 0; vec_8 < 2; ++vec_8) { + uint2 __23; + float4 v__21 = *(float4*)(ol_1 + ((i_24 * 8) + (vec_8 * 4))); + (reinterpret_cast<__nv_bfloat162*>(&__23))[0] = __float22bfloat162_rn(((float2*)(&v__21))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__23))[1] = __float22bfloat162_rn(((float2*)(&v__21))[1]); + *(uint2*)(layer_input_local_cast_8 + (vec_8 * 4)) = __23; + } + *(uint4*)(layer_input + ((((((int64_t)((int)blockIdx.x)) * (int64_t)4096) + (((int64_t)i_24) * (int64_t)512)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8)) + (int64_t)1792)) = *(uint4*)(layer_input_local_cast_8 + 0); + } + tl::cp_async_wait<0>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_25 = 0; i_25 < 2; ++i_25) { + *(uint4*)(w_shared_local_cast_9 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_25 * 512) + (((int)threadIdx.x) * 8)) + 13104)); + for (int vec_9 = 0; vec_9 < 2; ++vec_9) { + float4 __24; + uint2 v__22 = *(uint2*)(w_shared_local_cast_9 + (vec_9 * 4)); + ((float2*)(&__24))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__22))[0]); + ((float2*)(&__24))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__22))[1]); + *(float4*)(w_local + ((i_25 * 8) + (vec_9 * 4))) = __24; + } + } + #pragma unroll + for (int i_26 = 0; i_26 < 2; ++i_26) { + *(uint4*)(output_shared_local_cast_10 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_26 * 512) + (((int)threadIdx.x) * 8)) + 11056)); + for (int vec_10 = 0; vec_10 < 2; ++vec_10) { + float4 __25; + float4 __26; + float4 __27; + uint2 v__23 = *(uint2*)(output_shared_local_cast_10 + (vec_10 * 4)); + ((float2*)(&__27))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__23))[0]); + ((float2*)(&__27))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__23))[1]); + float4 v__24 = make_float4(rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0]); + __26.x = (__27.x*v__24.x); + __26.y = (__27.y*v__24.y); + __26.z = (__27.z*v__24.z); + __26.w = (__27.w*v__24.w); + float4 v__25 = *(float4*)(w_local + ((i_26 * 8) + (vec_10 * 4))); + __25.x = (__26.x*v__25.x); + __25.y = (__26.y*v__25.y); + __25.z = (__26.z*v__25.z); + __25.w = (__26.w*v__25.w); + *(float4*)(ol_1 + ((i_26 * 8) + (vec_10 * 4))) = __25; + } + } + #pragma unroll + for (int i_27 = 0; i_27 < 2; ++i_27) { + for (int vec_11 = 0; vec_11 < 2; ++vec_11) { + uint2 __28; + float4 v__26 = *(float4*)(ol_1 + ((i_27 * 8) + (vec_11 * 4))); + (reinterpret_cast<__nv_bfloat162*>(&__28))[0] = __float22bfloat162_rn(((float2*)(&v__26))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__28))[1] = __float22bfloat162_rn(((float2*)(&v__26))[1]); + *(uint2*)(layer_input_local_cast_11 + (vec_11 * 4)) = __28; + } + *(uint4*)(layer_input + ((((((int64_t)((int)blockIdx.x)) * (int64_t)4096) + (((int64_t)i_27) * (int64_t)512)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8)) + (int64_t)2816)) = *(uint4*)(layer_input_local_cast_11 + 0); + } + } + cudaTriggerProgrammaticLaunchCompletion(); +} + diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/596345ac7ba68225bdd1b9b6abe5e4fbb63f7c57ec2523668ca14b62460b457a/host_kernel.cu b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/596345ac7ba68225bdd1b9b6abe5e4fbb63f7c57ec2523668ca14b62460b457a/host_kernel.cu new file mode 100644 index 0000000..59d8e6b --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/596345ac7ba68225bdd1b9b6abe5e4fbb63f7c57ec2523668ca14b62460b457a/host_kernel.cu @@ -0,0 +1,3359 @@ +// tilelang target: c -keys=cpu +#define TVM_EXPORTS +#include "tvm/runtime/base.h" +#include "tvm/runtime/c_backend_api.h" +#include "tvm/ffi/c_api.h" +#include +#include +#include +#ifdef __OBJC__ +#include "tvm/runtime/device_api.h" +#include "tvm/ffi/function.h" +#include +#include +#include +#endif +void* __tvm_ffi__library_ctx = NULL; +static void* __tvm_error_ndim_mismatch_packed = NULL; +static void* __tvm_error_dtype_mismatch_packed = NULL; +static void* __tvm_error_expect_eq_packed = NULL; +static void* __tvm_error_constraint_violation_packed = NULL; +static void* __tvm_error_byte_offset_mismatch_packed = NULL; +static void* __tvm_error_device_type_mismatch_packed = NULL; +static void* __tvm_error_null_ptr_packed = NULL; +static void* __tvm_set_device_packed = NULL; +static void* mhc_pre_big_fuse_with_norm_tilelang_kernel_packed = NULL; +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_mhc_pre_big_fuse_with_norm_tilelang(void* self_handle, void* args, int32_t num_args, void* result); +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_mhc_pre_big_fuse_with_norm_tilelang(void* self_handle, void* args, int32_t num_args, void* result) { + __attribute__((aligned(64))) TVMFFIAny stack[16]; + void* stack_ffi_any = stack; + if (!((num_args == 9))) { + char __tvm_assert_msg_buf[512]; + snprintf(__tvm_assert_msg_buf, 512, "%s; expected: %lld, got: %lld", "mhc_pre_big_fuse_with_norm_tilelang: num_args should be 9", (long long)(num_args), (long long)(9)); + TVMFFIErrorSetRaisedFromCStr("RuntimeError", __tvm_assert_msg_buf); + return -1; + } + if (!(!(args == NULL))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang: args pointer is NULL"); + return -1; + } + int32_t gemm_out_mul_type_index = (((TVMFFIAny*)args)[0].type_index); + if (!(((((gemm_out_mul_type_index == 0) || (gemm_out_mul_type_index == 4)) || (gemm_out_mul_type_index == 7)) || (64 <= gemm_out_mul_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input gemm_out_mul expected pointer or tensor handle"); + return -1; + } + int32_t gemm_out_sqrsum_type_index = (((TVMFFIAny*)args)[1].type_index); + if (!(((((gemm_out_sqrsum_type_index == 0) || (gemm_out_sqrsum_type_index == 4)) || (gemm_out_sqrsum_type_index == 7)) || (64 <= gemm_out_sqrsum_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input gemm_out_sqrsum expected pointer or tensor handle"); + return -1; + } + int32_t hc_scale_type_index = (((TVMFFIAny*)args)[2].type_index); + if (!(((((hc_scale_type_index == 0) || (hc_scale_type_index == 4)) || (hc_scale_type_index == 7)) || (64 <= hc_scale_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input hc_scale expected pointer or tensor handle"); + return -1; + } + int32_t hc_base_type_index = (((TVMFFIAny*)args)[3].type_index); + if (!(((((hc_base_type_index == 0) || (hc_base_type_index == 4)) || (hc_base_type_index == 7)) || (64 <= hc_base_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input hc_base expected pointer or tensor handle"); + return -1; + } + int32_t residual_type_index = (((TVMFFIAny*)args)[4].type_index); + if (!(((((residual_type_index == 0) || (residual_type_index == 4)) || (residual_type_index == 7)) || (64 <= residual_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input residual expected pointer or tensor handle"); + return -1; + } + int32_t post_mix_type_index = (((TVMFFIAny*)args)[5].type_index); + if (!(((((post_mix_type_index == 0) || (post_mix_type_index == 4)) || (post_mix_type_index == 7)) || (64 <= post_mix_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input post_mix expected pointer or tensor handle"); + return -1; + } + int32_t comb_mix_type_index = (((TVMFFIAny*)args)[6].type_index); + if (!(((((comb_mix_type_index == 0) || (comb_mix_type_index == 4)) || (comb_mix_type_index == 7)) || (64 <= comb_mix_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input comb_mix expected pointer or tensor handle"); + return -1; + } + int32_t layer_input_type_index = (((TVMFFIAny*)args)[7].type_index); + if (!(((((layer_input_type_index == 0) || (layer_input_type_index == 4)) || (layer_input_type_index == 7)) || (64 <= layer_input_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input layer_input expected pointer or tensor handle"); + return -1; + } + int32_t norm_weight_type_index = (((TVMFFIAny*)args)[8].type_index); + if (!(((((norm_weight_type_index == 0) || (norm_weight_type_index == 4)) || (norm_weight_type_index == 7)) || (64 <= norm_weight_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input norm_weight expected pointer or tensor handle"); + return -1; + } + void* gemm_out_mul = ((gemm_out_mul_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[0].v_ptr) + 24)) : (((TVMFFIAny*)args)[0].v_ptr)); + void* gemm_out_sqrsum = ((gemm_out_sqrsum_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[1].v_ptr) + 24)) : (((TVMFFIAny*)args)[1].v_ptr)); + void* hc_scale = ((hc_scale_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[2].v_ptr) + 24)) : (((TVMFFIAny*)args)[2].v_ptr)); + void* hc_base = ((hc_base_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[3].v_ptr) + 24)) : (((TVMFFIAny*)args)[3].v_ptr)); + void* residual = ((residual_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[4].v_ptr) + 24)) : (((TVMFFIAny*)args)[4].v_ptr)); + void* post_mix = ((post_mix_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[5].v_ptr) + 24)) : (((TVMFFIAny*)args)[5].v_ptr)); + void* comb_mix = ((comb_mix_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[6].v_ptr) + 24)) : (((TVMFFIAny*)args)[6].v_ptr)); + void* layer_input = ((layer_input_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[7].v_ptr) + 24)) : (((TVMFFIAny*)args)[7].v_ptr)); + void* norm_weight = ((norm_weight_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[8].v_ptr) + 24)) : (((TVMFFIAny*)args)[8].v_ptr)); + bool mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_is_null = (gemm_out_mul == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.gemm_out_mul is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_is_null = (gemm_out_sqrsum == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.gemm_out_sqrsum is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_hc_scale_is_null = (hc_scale == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_hc_scale_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.hc_scale is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_hc_base_is_null = (hc_base == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_hc_base_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.hc_base is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_residual_is_null = (residual == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_residual_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.residual is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_post_mix_is_null = (post_mix == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_post_mix_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.post_mix is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_comb_mix_is_null = (comb_mix == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_comb_mix_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.comb_mix is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_layer_input_is_null = (layer_input == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_layer_input_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.layer_input is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_norm_weight_is_null = (norm_weight == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_norm_weight_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.norm_weight is expected to have non-NULL pointer"); + return -1; + } + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape = (((DLTensor*)gemm_out_mul)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape = (((DLTensor*)gemm_out_sqrsum)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_hc_scale_shape = (((DLTensor*)hc_scale)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_hc_base_shape = (((DLTensor*)hc_base)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_residual_shape = (((DLTensor*)residual)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape = (((DLTensor*)post_mix)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape = (((DLTensor*)comb_mix)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape = (((DLTensor*)layer_input)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_norm_weight_shape = (((DLTensor*)norm_weight)[0].shape); + if ((((DLTensor*)gemm_out_mul)[0].ndim) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_1; + result_1.type_index = kTVMFFINone; + result_1.zero_padding = 0; + result_1.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_1) != 0) { + return -1; + } + } + if (!((bool)1)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "Symbolic shape variable num_tokens requires at least one non-null buffer among: mhc_pre_big_fuse_with_norm_tilelang.gemm_out_mul, mhc_pre_big_fuse_with_norm_tilelang.gemm_out_sqrsum, mhc_pre_big_fuse_with_norm_tilelang.residual, mhc_pre_big_fuse_with_norm_tilelang.post_mix, mhc_pre_big_fuse_with_norm_tilelang.comb_mix, mhc_pre_big_fuse_with_norm_tilelang.layer_input"); + return -1; + } + int32_t num_tokens = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]); + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides = (((DLTensor*)gemm_out_mul)[0].strides); + int32_t dev_id = (((DLTensor*)gemm_out_mul)[0].device.device_id); + void* gemm_out_mul_1 = (((DLTensor*)gemm_out_mul)[0].data); + if ((((DLTensor*)gemm_out_sqrsum)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_2; + result_2.type_index = kTVMFFINone; + result_2.zero_padding = 0; + result_2.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_2) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides = (((DLTensor*)gemm_out_sqrsum)[0].strides); + void* gemm_out_sqrsum_1 = (((DLTensor*)gemm_out_sqrsum)[0].data); + if ((((DLTensor*)hc_scale)[0].ndim) != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_3; + result_3.type_index = kTVMFFINone; + result_3.zero_padding = 0; + result_3.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_3) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides = (((DLTensor*)hc_scale)[0].strides); + void* hc_scale_1 = (((DLTensor*)hc_scale)[0].data); + if ((((DLTensor*)hc_base)[0].ndim) != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_4; + result_4.type_index = kTVMFFINone; + result_4.zero_padding = 0; + result_4.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_4) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides = (((DLTensor*)hc_base)[0].strides); + void* hc_base_1 = (((DLTensor*)hc_base)[0].data); + if ((((DLTensor*)residual)[0].ndim) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_5; + result_5.type_index = kTVMFFINone; + result_5.zero_padding = 0; + result_5.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_5) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_residual_strides = (((DLTensor*)residual)[0].strides); + void* residual_1 = (((DLTensor*)residual)[0].data); + if ((((DLTensor*)post_mix)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_6; + result_6.type_index = kTVMFFINone; + result_6.zero_padding = 0; + result_6.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_6) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides = (((DLTensor*)post_mix)[0].strides); + void* post_mix_1 = (((DLTensor*)post_mix)[0].data); + if ((((DLTensor*)comb_mix)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_7; + result_7.type_index = kTVMFFINone; + result_7.zero_padding = 0; + result_7.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_7) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides = (((DLTensor*)comb_mix)[0].strides); + void* comb_mix_1 = (((DLTensor*)comb_mix)[0].data); + if ((((DLTensor*)layer_input)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_8; + result_8.type_index = kTVMFFINone; + result_8.zero_padding = 0; + result_8.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_8) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides = (((DLTensor*)layer_input)[0].strides); + void* layer_input_1 = (((DLTensor*)layer_input)[0].data); + if ((((DLTensor*)norm_weight)[0].ndim) != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_9; + result_9.type_index = kTVMFFINone; + result_9.zero_padding = 0; + result_9.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_9) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides = (((DLTensor*)norm_weight)[0].strides); + void* norm_weight_1 = (((DLTensor*)norm_weight)[0].data); + if ((((((DLTensor*)gemm_out_mul)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)gemm_out_mul)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)gemm_out_mul)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_10; + result_10.type_index = kTVMFFINone; + result_10.zero_padding = 0; + result_10.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_10) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[0]) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_11; + result_11.type_index = kTVMFFINone; + result_11.zero_padding = 0; + result_11.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_11) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[2]) != 24) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)24; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[2])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_12; + result_12.type_index = kTVMFFINone; + result_12.zero_padding = 0; + result_12.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_12) != 0) { + return -1; + } + } + int32_t condval; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval = 1; + } else { + condval = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[2]); + } + if (condval != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_1; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval_1 = 1; + } else { + condval_1 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[2]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_1); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_13; + result_13.type_index = kTVMFFINone; + result_13.zero_padding = 0; + result_13.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_13) != 0) { + return -1; + } + } + int32_t condval_2; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval_2 = 1; + } else { + condval_2 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[1]); + } + if ((condval_2 != 24) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_14; + result_14.type_index = kTVMFFINone; + result_14.zero_padding = 0; + result_14.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_14) != 0) { + return -1; + } + } + int32_t condval_3; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval_3 = 1; + } else { + condval_3 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[0]); + } + if (((num_tokens * 24) != condval_3) && (num_tokens != 0)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_15; + result_15.type_index = kTVMFFINone; + result_15.zero_padding = 0; + result_15.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_15) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)gemm_out_mul)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_16; + result_16.type_index = kTVMFFINone; + result_16.zero_padding = 0; + result_16.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_16) != 0) { + return -1; + } + } + if ((((DLTensor*)gemm_out_mul)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_17; + result_17.type_index = kTVMFFINone; + result_17.zero_padding = 0; + result_17.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_17) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (gemm_out_mul_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_18; + result_18.type_index = kTVMFFINone; + result_18.zero_padding = 0; + result_18.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_18) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)gemm_out_sqrsum)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)gemm_out_sqrsum)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)gemm_out_sqrsum)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_19; + result_19.type_index = kTVMFFINone; + result_19.zero_padding = 0; + result_19.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_19) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[0]) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_20; + result_20.type_index = kTVMFFINone; + result_20.zero_padding = 0; + result_20.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_20) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[1])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_21; + result_21.type_index = kTVMFFINone; + result_21.zero_padding = 0; + result_21.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_21) != 0) { + return -1; + } + } + int32_t condval_4; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides == NULL)) { + condval_4 = 1; + } else { + condval_4 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides)[1]); + } + if ((condval_4 != 1) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_22; + result_22.type_index = kTVMFFINone; + result_22.zero_padding = 0; + result_22.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_22) != 0) { + return -1; + } + } + int32_t condval_5; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides == NULL)) { + condval_5 = 1; + } else { + condval_5 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides)[0]); + } + if ((((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != condval_5) && (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != 0)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_23; + result_23.type_index = kTVMFFINone; + result_23.zero_padding = 0; + result_23.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_23) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)gemm_out_sqrsum)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_24; + result_24.type_index = kTVMFFINone; + result_24.zero_padding = 0; + result_24.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_24) != 0) { + return -1; + } + } + if ((((DLTensor*)gemm_out_sqrsum)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_25; + result_25.type_index = kTVMFFINone; + result_25.zero_padding = 0; + result_25.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_25) != 0) { + return -1; + } + } + if ((((DLTensor*)gemm_out_sqrsum)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_26; + result_26.type_index = kTVMFFINone; + result_26.zero_padding = 0; + result_26.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_26) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (gemm_out_sqrsum_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_27; + result_27.type_index = kTVMFFINone; + result_27.zero_padding = 0; + result_27.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_27) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)hc_scale)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)hc_scale)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)hc_scale)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_28; + result_28.type_index = kTVMFFINone; + result_28.zero_padding = 0; + result_28.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_28) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_shape)[0]) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_29; + result_29.type_index = kTVMFFINone; + result_29.zero_padding = 0; + result_29.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_29) != 0) { + return -1; + } + } + int32_t condval_6; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides == NULL)) { + condval_6 = 1; + } else { + condval_6 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides)[0]); + } + if (condval_6 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_7; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides == NULL)) { + condval_7 = 1; + } else { + condval_7 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides)[0]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_7); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_30; + result_30.type_index = kTVMFFINone; + result_30.zero_padding = 0; + result_30.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_30) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)hc_scale)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_31; + result_31.type_index = kTVMFFINone; + result_31.zero_padding = 0; + result_31.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_31) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_scale)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_32; + result_32.type_index = kTVMFFINone; + result_32.zero_padding = 0; + result_32.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_32) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_scale)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_33; + result_33.type_index = kTVMFFINone; + result_33.zero_padding = 0; + result_33.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_33) != 0) { + return -1; + } + } + if (hc_scale_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_34; + result_34.type_index = kTVMFFINone; + result_34.zero_padding = 0; + result_34.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_34) != 0) { + return -1; + } + } + if ((((((DLTensor*)hc_base)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)hc_base)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)hc_base)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_35; + result_35.type_index = kTVMFFINone; + result_35.zero_padding = 0; + result_35.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_35) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_shape)[0]) != 24) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)24; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_36; + result_36.type_index = kTVMFFINone; + result_36.zero_padding = 0; + result_36.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_36) != 0) { + return -1; + } + } + int32_t condval_8; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides == NULL)) { + condval_8 = 1; + } else { + condval_8 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides)[0]); + } + if (condval_8 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_9; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides == NULL)) { + condval_9 = 1; + } else { + condval_9 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides)[0]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_9); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_37; + result_37.type_index = kTVMFFINone; + result_37.zero_padding = 0; + result_37.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_37) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)hc_base)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_38; + result_38.type_index = kTVMFFINone; + result_38.zero_padding = 0; + result_38.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_38) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_base)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_39; + result_39.type_index = kTVMFFINone; + result_39.zero_padding = 0; + result_39.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_39) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_base)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_40; + result_40.type_index = kTVMFFINone; + result_40.zero_padding = 0; + result_40.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_40) != 0) { + return -1; + } + } + if (hc_base_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_41; + result_41.type_index = kTVMFFINone; + result_41.zero_padding = 0; + result_41.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_41) != 0) { + return -1; + } + } + if ((((((DLTensor*)residual)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)residual)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)residual)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)residual)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)residual)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_42; + result_42.type_index = kTVMFFINone; + result_42.zero_padding = 0; + result_42.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_42) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_43; + result_43.type_index = kTVMFFINone; + result_43.zero_padding = 0; + result_43.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_43) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[1]) != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_44; + result_44.type_index = kTVMFFINone; + result_44.zero_padding = 0; + result_44.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_44) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[2]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[2])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_45; + result_45.type_index = kTVMFFINone; + result_45.zero_padding = 0; + result_45.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_45) != 0) { + return -1; + } + } + int32_t condval_10; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_10 = 1; + } else { + condval_10 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[2]); + } + if (condval_10 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_11; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_11 = 1; + } else { + condval_11 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[2]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_11); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_46; + result_46.type_index = kTVMFFINone; + result_46.zero_padding = 0; + result_46.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_46) != 0) { + return -1; + } + } + int32_t condval_12; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_12 = 1; + } else { + condval_12 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[1]); + } + if (condval_12 != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_13; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_13 = 1; + } else { + condval_13 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_13); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_47; + result_47.type_index = kTVMFFINone; + result_47.zero_padding = 0; + result_47.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_47) != 0) { + return -1; + } + } + int32_t condval_14; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_14 = 1; + } else { + condval_14 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[0]); + } + if ((condval_14 != 16384) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_48; + result_48.type_index = kTVMFFINone; + result_48.zero_padding = 0; + result_48.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_48) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)residual)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_49; + result_49.type_index = kTVMFFINone; + result_49.zero_padding = 0; + result_49.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_49) != 0) { + return -1; + } + } + if ((((DLTensor*)residual)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)residual)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_50; + result_50.type_index = kTVMFFINone; + result_50.zero_padding = 0; + result_50.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_50) != 0) { + return -1; + } + } + if ((((DLTensor*)residual)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_51; + result_51.type_index = kTVMFFINone; + result_51.zero_padding = 0; + result_51.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_51) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (residual_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_52; + result_52.type_index = kTVMFFINone; + result_52.zero_padding = 0; + result_52.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_52) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)post_mix)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)post_mix)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)post_mix)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_53; + result_53.type_index = kTVMFFINone; + result_53.zero_padding = 0; + result_53.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_53) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_54; + result_54.type_index = kTVMFFINone; + result_54.zero_padding = 0; + result_54.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_54) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[1]) != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_55; + result_55.type_index = kTVMFFINone; + result_55.zero_padding = 0; + result_55.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_55) != 0) { + return -1; + } + } + int32_t condval_15; + if ((mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides == NULL)) { + condval_15 = 1; + } else { + condval_15 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides)[1]); + } + if (condval_15 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_16; + if ((mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides == NULL)) { + condval_16 = 1; + } else { + condval_16 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_16); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_56; + result_56.type_index = kTVMFFINone; + result_56.zero_padding = 0; + result_56.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_56) != 0) { + return -1; + } + } + int32_t condval_17; + if ((mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides == NULL)) { + condval_17 = 1; + } else { + condval_17 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides)[0]); + } + if ((condval_17 != 4) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_57; + result_57.type_index = kTVMFFINone; + result_57.zero_padding = 0; + result_57.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_57) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)post_mix)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_58; + result_58.type_index = kTVMFFINone; + result_58.zero_padding = 0; + result_58.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_58) != 0) { + return -1; + } + } + if ((((DLTensor*)post_mix)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_59; + result_59.type_index = kTVMFFINone; + result_59.zero_padding = 0; + result_59.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_59) != 0) { + return -1; + } + } + if ((((DLTensor*)post_mix)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_60; + result_60.type_index = kTVMFFINone; + result_60.zero_padding = 0; + result_60.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_60) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (post_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_61; + result_61.type_index = kTVMFFINone; + result_61.zero_padding = 0; + result_61.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_61) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)comb_mix)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)comb_mix)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)comb_mix)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_62; + result_62.type_index = kTVMFFINone; + result_62.zero_padding = 0; + result_62.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_62) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_63; + result_63.type_index = kTVMFFINone; + result_63.zero_padding = 0; + result_63.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_63) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[1]) != 16) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_64; + result_64.type_index = kTVMFFINone; + result_64.zero_padding = 0; + result_64.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_64) != 0) { + return -1; + } + } + int32_t condval_18; + if ((mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides == NULL)) { + condval_18 = 1; + } else { + condval_18 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides)[1]); + } + if (condval_18 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_19; + if ((mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides == NULL)) { + condval_19 = 1; + } else { + condval_19 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_19); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_65; + result_65.type_index = kTVMFFINone; + result_65.zero_padding = 0; + result_65.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_65) != 0) { + return -1; + } + } + int32_t condval_20; + if ((mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides == NULL)) { + condval_20 = 1; + } else { + condval_20 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides)[0]); + } + if ((condval_20 != 16) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_66; + result_66.type_index = kTVMFFINone; + result_66.zero_padding = 0; + result_66.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_66) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)comb_mix)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_67; + result_67.type_index = kTVMFFINone; + result_67.zero_padding = 0; + result_67.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_67) != 0) { + return -1; + } + } + if ((((DLTensor*)comb_mix)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_68; + result_68.type_index = kTVMFFINone; + result_68.zero_padding = 0; + result_68.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_68) != 0) { + return -1; + } + } + if ((((DLTensor*)comb_mix)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_69; + result_69.type_index = kTVMFFINone; + result_69.zero_padding = 0; + result_69.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_69) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (comb_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_70; + result_70.type_index = kTVMFFINone; + result_70.zero_padding = 0; + result_70.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_70) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)layer_input)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)layer_input)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)layer_input)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_71; + result_71.type_index = kTVMFFINone; + result_71.zero_padding = 0; + result_71.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_71) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_72; + result_72.type_index = kTVMFFINone; + result_72.zero_padding = 0; + result_72.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_72) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[1]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_73; + result_73.type_index = kTVMFFINone; + result_73.zero_padding = 0; + result_73.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_73) != 0) { + return -1; + } + } + int32_t condval_21; + if ((mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides == NULL)) { + condval_21 = 1; + } else { + condval_21 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides)[1]); + } + if (condval_21 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_22; + if ((mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides == NULL)) { + condval_22 = 1; + } else { + condval_22 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_22); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_74; + result_74.type_index = kTVMFFINone; + result_74.zero_padding = 0; + result_74.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_74) != 0) { + return -1; + } + } + int32_t condval_23; + if ((mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides == NULL)) { + condval_23 = 1; + } else { + condval_23 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides)[0]); + } + if ((condval_23 != 4096) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_75; + result_75.type_index = kTVMFFINone; + result_75.zero_padding = 0; + result_75.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_75) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)layer_input)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_76; + result_76.type_index = kTVMFFINone; + result_76.zero_padding = 0; + result_76.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_76) != 0) { + return -1; + } + } + if ((((DLTensor*)layer_input)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_77; + result_77.type_index = kTVMFFINone; + result_77.zero_padding = 0; + result_77.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_77) != 0) { + return -1; + } + } + if ((((DLTensor*)layer_input)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_78; + result_78.type_index = kTVMFFINone; + result_78.zero_padding = 0; + result_78.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_78) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (layer_input_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_79; + result_79.type_index = kTVMFFINone; + result_79.zero_padding = 0; + result_79.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_79) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)norm_weight)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)norm_weight)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)norm_weight)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_80; + result_80.type_index = kTVMFFINone; + result_80.zero_padding = 0; + result_80.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_80) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_shape)[0]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_81; + result_81.type_index = kTVMFFINone; + result_81.zero_padding = 0; + result_81.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_81) != 0) { + return -1; + } + } + int32_t condval_24; + if ((mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides == NULL)) { + condval_24 = 1; + } else { + condval_24 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides)[0]); + } + if (condval_24 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_25; + if ((mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides == NULL)) { + condval_25 = 1; + } else { + condval_25 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides)[0]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_25); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_82; + result_82.type_index = kTVMFFINone; + result_82.zero_padding = 0; + result_82.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_82) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)norm_weight)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_83; + result_83.type_index = kTVMFFINone; + result_83.zero_padding = 0; + result_83.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_83) != 0) { + return -1; + } + } + if ((((DLTensor*)norm_weight)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_84; + result_84.type_index = kTVMFFINone; + result_84.zero_padding = 0; + result_84.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_84) != 0) { + return -1; + } + } + if ((((DLTensor*)norm_weight)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_85; + result_85.type_index = kTVMFFINone; + result_85.zero_padding = 0; + result_85.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_85) != 0) { + return -1; + } + } + if (norm_weight_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_86; + result_86.type_index = kTVMFFINone; + result_86.zero_padding = 0; + result_86.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_86) != 0) { + return -1; + } + } + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = ((int64_t)2); + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = ((int64_t)dev_id); + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + if (__tvm_set_device_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_set_device", &__tvm_set_device_packed) != 0) { + return -1; + } + } + TVMFFIAny result_87; + result_87.type_index = kTVMFFINone; + result_87.zero_padding = 0; + result_87.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_set_device_packed, (TVMFFIAny*) stack_ffi_any, 2, &result_87) != 0) { + return -1; + } + if (comb_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = comb_mix_1; + if (gemm_out_mul_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = gemm_out_mul_1; + if (gemm_out_sqrsum_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = gemm_out_sqrsum_1; + if (hc_base_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_ptr) = hc_base_1; + if (hc_scale_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_ptr) = hc_scale_1; + if (layer_input_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_ptr) = layer_input_1; + if (norm_weight_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_ptr) = norm_weight_1; + if (post_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_ptr) = post_mix_1; + if (residual_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_ptr) = residual_1; + (((TVMFFIAny*)stack_ffi_any)[9].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[9].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[9].v_int64) = ((int64_t)num_tokens); + (((TVMFFIAny*)stack_ffi_any)[10].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[10].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[10].v_int64) = ((int64_t)num_tokens); + (((TVMFFIAny*)stack_ffi_any)[11].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[11].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[11].v_int64) = ((int64_t)96); + (((TVMFFIAny*)stack_ffi_any)[12].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[12].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[12].v_int64) = ((int64_t)1); + (((TVMFFIAny*)stack_ffi_any)[13].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[13].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[13].v_int64) = ((int64_t)1); + (((TVMFFIAny*)stack_ffi_any)[14].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[14].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[14].v_int64) = ((int64_t)29040); + (((TVMFFIAny*)stack_ffi_any)[15].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[15].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[15].v_int64) = (int64_t)0; + if (mhc_pre_big_fuse_with_norm_tilelang_kernel_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "mhc_pre_big_fuse_with_norm_tilelang_kernel", &mhc_pre_big_fuse_with_norm_tilelang_kernel_packed) != 0) { + return -1; + } + } + TVMFFIAny result_88; + result_88.type_index = kTVMFFINone; + result_88.zero_padding = 0; + result_88.v_int64 = 0; + if (TVMFFIFunctionCall(mhc_pre_big_fuse_with_norm_tilelang_kernel_packed, (TVMFFIAny*) stack_ffi_any, 15, &result_88) != 0) { + return -1; + } + return 0; +} + +// CodegenC: NOTE: Auto-generated entry function +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_main(void* self, void* args,int num_args, void* result) { + return __tvm_ffi_mhc_pre_big_fuse_with_norm_tilelang(self, args, num_args, result); +} diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/596345ac7ba68225bdd1b9b6abe5e4fbb63f7c57ec2523668ca14b62460b457a/params.pkl b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/596345ac7ba68225bdd1b9b6abe5e4fbb63f7c57ec2523668ca14b62460b457a/params.pkl new file mode 100644 index 0000000..6dd6dc4 Binary files /dev/null and b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/596345ac7ba68225bdd1b9b6abe5e4fbb63f7c57ec2523668ca14b62460b457a/params.pkl differ diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/690cfe1726579f52e2028c161d3001b9f82af97555a40aab825d6e0140ad4e12/device_kernel.cu b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/690cfe1726579f52e2028c161d3001b9f82af97555a40aab825d6e0140ad4e12/device_kernel.cu new file mode 100644 index 0000000..bbcfb73 --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/690cfe1726579f52e2028c161d3001b9f82af97555a40aab825d6e0140ad4e12/device_kernel.cu @@ -0,0 +1,420 @@ +#include +#include +#include +#include +#include +#include +#include +#ifdef ENABLE_BF16 +#include +#endif + +extern "C" __global__ void mhc_pre_big_fuse_with_norm_tilelang_kernel(float* comb_mix, const float* gemm_out_mul, const float* gemm_out_sqrsum, const float* hc_base, const float* hc_scale, bfloat16_t* layer_input, const bfloat16_t* norm_weight, float* post_mix, const bfloat16_t* residual, int num_tokens); +extern "C" __global__ void __launch_bounds__(96, 1) mhc_pre_big_fuse_with_norm_tilelang_kernel(float* comb_mix, const float* gemm_out_mul, const float* gemm_out_sqrsum, const float* hc_base, const float* hc_scale, bfloat16_t* layer_input, const bfloat16_t* norm_weight, float* post_mix, const bfloat16_t* residual, int num_tokens) { + extern __shared__ __align__(1024) uchar buf_dyn_shmem[]; + float mixes[1]; + float rms[1]; + float cm[1]; + float row_max[1]; + float row_sum[1]; + float col_sum[1]; + float sumsq_per_pos[16]; + float sumsq[1]; + float rsqrt_norm[1]; + float xl[64]; + float ol[16]; + bfloat16_t xs_local_cast[8]; + bfloat16_t xs_local_cast_1[8]; + bfloat16_t xs_local_cast_2[8]; + float w_local[16]; + float ol_1[16]; + bfloat16_t w_shared_local_cast_3[8]; + bfloat16_t output_shared_local_cast_4[8]; + bfloat16_t layer_input_local_cast_5[8]; + bfloat16_t w_shared_local_cast_6[8]; + bfloat16_t output_shared_local_cast_7[8]; + bfloat16_t layer_input_local_cast_8[8]; + bfloat16_t w_shared_local_cast_9[8]; + bfloat16_t output_shared_local_cast_10[8]; + bfloat16_t layer_input_local_cast_11[8]; + mixes[0] = 0x0p+0f/*0.000000e+00*/; + rms[0] = 0x0p+0f/*0.000000e+00*/; + cudaGridDependencySynchronize(); + rms[0] = (rms[0] + gemm_out_sqrsum[((int64_t)((int)blockIdx.x))]); + rms[0] = rsqrtf(((rms[0] / 0x1p+14f/*1.638400e+04*/) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + mixes[0] = 0x0p+0f/*0.000000e+00*/; + mixes[0] = (mixes[0] + gemm_out_mul[((((int64_t)((int)blockIdx.x)) * (int64_t)24) + (((int64_t)((int)threadIdx.x)) % (int64_t)24))]); + mixes[0] = (mixes[0] * rms[0]); + if ((((int)threadIdx.x) / 24) == 0) { + ((float*)buf_dyn_shmem)[(((int)threadIdx.x) % 24)] = mixes[0]; + } + __syncthreads(); + if (((int)threadIdx.x) < 32) { + if (((int)threadIdx.x) < 4) { + post_mix[((((int64_t)((int)blockIdx.x)) * (int64_t)4) + ((int64_t)((int)threadIdx.x)))] = ((0x1p+0f/*1.000000e+00*/ / (0x1p+0f/*1.000000e+00*/ + expf((0x0p+0f/*0.000000e+00*/ - ((((float*)buf_dyn_shmem)[(((int)threadIdx.x) + 4)] * hc_scale[1]) + hc_base[(((int)threadIdx.x) + 4)]))))) * 0x1p+1f/*2.000000e+00*/); + } + cm[0] = ((((float*)buf_dyn_shmem)[((((int)threadIdx.x) & 15) + 8)] * hc_scale[2]) + hc_base[((((int)threadIdx.x) & 15) + 8)]); + row_max[0] = -CUDART_INF_F; + row_max[0] = max(row_max[0], cm[0]); + row_max[0] = tl::AllReduce>::run(row_max[0]); + cm[0] = expf((cm[0] - row_max[0])); + row_sum[0] = 0x0p+0f/*0.000000e+00*/; + row_sum[0] = (row_sum[0] + cm[0]); + row_sum[0] = tl::AllReduce>::run(row_sum[0]); + cm[0] = ((cm[0] / row_sum[0]) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/); + col_sum[0] = 0x0p+0f/*0.000000e+00*/; + col_sum[0] = (col_sum[0] + cm[0]); + col_sum[0] = tl::AllReduce>::run(col_sum[0]); + cm[0] = (cm[0] / (col_sum[0] + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + for (int __1 = 0; __1 < 19; ++__1) { + row_sum[0] = 0x0p+0f/*0.000000e+00*/; + row_sum[0] = (row_sum[0] + cm[0]); + row_sum[0] = tl::AllReduce>::run(row_sum[0]); + cm[0] = (cm[0] / (row_sum[0] + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + col_sum[0] = 0x0p+0f/*0.000000e+00*/; + col_sum[0] = (col_sum[0] + cm[0]); + col_sum[0] = tl::AllReduce>::run(col_sum[0]); + cm[0] = (cm[0] / (col_sum[0] + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + } + if ((((int)threadIdx.x) >> 4) == 0) { + comb_mix[((((int64_t)((int)blockIdx.x)) * (int64_t)16) + (((int64_t)((int)threadIdx.x)) & (int64_t)15))] = cm[0]; + } + } else { + if (((int)threadIdx.x) < 36) { + ((float*)buf_dyn_shmem)[(((int)threadIdx.x) + 7224)] = ((0x1p+0f/*1.000000e+00*/ / (0x1p+0f/*1.000000e+00*/ + expf((0x0p+0f/*0.000000e+00*/ - ((((float*)buf_dyn_shmem)[(((int)threadIdx.x) - 32)] * hc_scale[0]) + hc_base[(((int)threadIdx.x) - 32)]))))) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/); + } + #pragma unroll + for (int i = 0; i < 4; ++i) { + float broadcast_var = 0x0p+0f/*0.000000e+00*/; + *(float4*)(sumsq_per_pos + (i * 4)) = make_float4(broadcast_var, broadcast_var, broadcast_var, broadcast_var); + } + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_1 = 0; i_1 < 8; ++i_1) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i_1 >> 1) * 1024) + (((((i_1 * 64) + ((int)threadIdx.x)) + 96) & 127) * 8)) + 48)])), (&(residual[(((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + ((((int64_t)i_1) >> (int64_t)1) * (int64_t)4096)) + (((((((int64_t)i_1) * (int64_t)64) + ((int64_t)((int)threadIdx.x))) + (int64_t)96) & (int64_t)127) * (int64_t)8))]))); + } + tl::cp_async_commit(); + #pragma unroll + for (int i_2 = 0; i_2 < 8; ++i_2) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i_2 >> 1) * 1024) + (((((i_2 * 64) + ((int)threadIdx.x)) + 96) & 127) * 8)) + 4144)])), (&(residual[((((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + ((((int64_t)i_2) >> (int64_t)1) * (int64_t)4096)) + (((((((int64_t)i_2) * (int64_t)64) + ((int64_t)((int)threadIdx.x))) + (int64_t)96) & (int64_t)127) * (int64_t)8)) + (int64_t)1024)]))); + } + tl::cp_async_commit(); + for (int i0_h = 0; i0_h < 2; ++i0_h) { + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_3 = 0; i_3 < 8; ++i_3) { + *(uint4*)(xs_local_cast + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + ((((i0_h * 4096) + (i_3 * 512)) + (((int)threadIdx.x) * 8)) - 208)); + for (int vec = 0; vec < 2; ++vec) { + float4 __2; + uint2 v_ = *(uint2*)(xs_local_cast + (vec * 4)); + ((float2*)(&__2))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v_))[0]); + ((float2*)(&__2))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v_))[1]); + *(float4*)(xl + ((i_3 * 8) + (vec * 4))) = __2; + } + } + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_4 = 0; i_4 < 8; ++i_4) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i0_h * 4096) + ((i_4 >> 1) * 1024)) + (((((i_4 * 64) + ((int)threadIdx.x)) + 96) & 127) * 8)) + 48)])), (&(residual[(((((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + ((((int64_t)i_4) >> (int64_t)1) * (int64_t)4096)) + (((int64_t)i0_h) * (int64_t)1024)) + (((((((int64_t)i_4) * (int64_t)64) + ((int64_t)((int)threadIdx.x))) + (int64_t)96) & (int64_t)127) * (int64_t)8)) + (int64_t)2048)]))); + } + tl::cp_async_commit(); + #pragma unroll + for (int i_5 = 0; i_5 < 4; ++i_5) { + float broadcast_var_1 = 0x0p+0f/*0.000000e+00*/; + *(float4*)(ol + (i_5 * 4)) = make_float4(broadcast_var_1, broadcast_var_1, broadcast_var_1, broadcast_var_1); + } + tl::__sync_thread_partial<3, 64>(); + for (int i_hc = 0; i_hc < 4; ++i_hc) { + float pre = ((float*)buf_dyn_shmem)[(i_hc + 7256)]; + #pragma unroll + for (int i_6 = 0; i_6 < 16; ++i_6) { + ol[i_6] = (ol[i_6] + (pre * xl[((i_hc * 16) + i_6)])); + } + } + #pragma unroll + for (int i_7 = 0; i_7 < 4; ++i_7) { + float4 __3; + float4 v__1 = *(float4*)(sumsq_per_pos + (i_7 * 4)); + float4 __4; + float4 v__2 = *(float4*)(ol + (i_7 * 4)); + __4.x = (v__2.x*v__2.x); + __4.y = (v__2.y*v__2.y); + __4.z = (v__2.z*v__2.z); + __4.w = (v__2.w*v__2.w); + __3.x = (v__1.x+__4.x); + __3.y = (v__1.y+__4.y); + __3.z = (v__1.z+__4.z); + __3.w = (v__1.w+__4.w); + *(float4*)(sumsq_per_pos + (i_7 * 4)) = __3; + uint2 __5; + float4 v__3 = *(float4*)(ol + (i_7 * 4)); + (reinterpret_cast<__nv_bfloat162*>(&__5))[0] = __float22bfloat162_rn(((float2*)(&v__3))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__5))[1] = __float22bfloat162_rn(((float2*)(&v__3))[1]); + *(uint2*)(((bfloat16_t*)buf_dyn_shmem) + (((((i0_h * 1024) + ((i_7 >> 1) * 512)) + (((int)threadIdx.x) * 8)) + ((i_7 & 1) * 4)) + 7984)) = __5; + } + } + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_8 = 0; i_8 < 8; ++i_8) { + *(uint4*)(xs_local_cast_1 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_8 * 512) + (((int)threadIdx.x) * 8)) - 208)); + for (int vec_1 = 0; vec_1 < 2; ++vec_1) { + float4 __6; + uint2 v__4 = *(uint2*)(xs_local_cast_1 + (vec_1 * 4)); + ((float2*)(&__6))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__4))[0]); + ((float2*)(&__6))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__4))[1]); + *(float4*)(xl + ((i_8 * 8) + (vec_1 * 4))) = __6; + } + } + #pragma unroll + for (int i_9 = 0; i_9 < 4; ++i_9) { + float broadcast_var_2 = 0x0p+0f/*0.000000e+00*/; + *(float4*)(ol + (i_9 * 4)) = make_float4(broadcast_var_2, broadcast_var_2, broadcast_var_2, broadcast_var_2); + } + for (int i_hc_1 = 0; i_hc_1 < 4; ++i_hc_1) { + float pre_1 = ((float*)buf_dyn_shmem)[(i_hc_1 + 7256)]; + #pragma unroll + for (int i_10 = 0; i_10 < 16; ++i_10) { + ol[i_10] = (ol[i_10] + (pre_1 * xl[((i_hc_1 * 16) + i_10)])); + } + } + #pragma unroll + for (int i_11 = 0; i_11 < 4; ++i_11) { + float4 __7; + float4 v__5 = *(float4*)(sumsq_per_pos + (i_11 * 4)); + float4 __8; + float4 v__6 = *(float4*)(ol + (i_11 * 4)); + __8.x = (v__6.x*v__6.x); + __8.y = (v__6.y*v__6.y); + __8.z = (v__6.z*v__6.z); + __8.w = (v__6.w*v__6.w); + __7.x = (v__5.x+__8.x); + __7.y = (v__5.y+__8.y); + __7.z = (v__5.z+__8.z); + __7.w = (v__5.w+__8.w); + *(float4*)(sumsq_per_pos + (i_11 * 4)) = __7; + uint2 __9; + float4 v__7 = *(float4*)(ol + (i_11 * 4)); + (reinterpret_cast<__nv_bfloat162*>(&__9))[0] = __float22bfloat162_rn(((float2*)(&v__7))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__9))[1] = __float22bfloat162_rn(((float2*)(&v__7))[1]); + *(uint2*)(((bfloat16_t*)buf_dyn_shmem) + (((((i_11 >> 1) * 512) + (((int)threadIdx.x) * 8)) + ((i_11 & 1) * 4)) + 10032)) = __9; + } + tl::cp_async_wait<0>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_12 = 0; i_12 < 8; ++i_12) { + *(uint4*)(xs_local_cast_2 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_12 * 512) + (((int)threadIdx.x) * 8)) + 3888)); + for (int vec_2 = 0; vec_2 < 2; ++vec_2) { + float4 __10; + uint2 v__8 = *(uint2*)(xs_local_cast_2 + (vec_2 * 4)); + ((float2*)(&__10))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__8))[0]); + ((float2*)(&__10))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__8))[1]); + *(float4*)(xl + ((i_12 * 8) + (vec_2 * 4))) = __10; + } + } + #pragma unroll + for (int i_13 = 0; i_13 < 4; ++i_13) { + float broadcast_var_3 = 0x0p+0f/*0.000000e+00*/; + *(float4*)(ol + (i_13 * 4)) = make_float4(broadcast_var_3, broadcast_var_3, broadcast_var_3, broadcast_var_3); + } + for (int i_hc_2 = 0; i_hc_2 < 4; ++i_hc_2) { + float pre_2 = ((float*)buf_dyn_shmem)[(i_hc_2 + 7256)]; + #pragma unroll + for (int i_14 = 0; i_14 < 16; ++i_14) { + ol[i_14] = (ol[i_14] + (pre_2 * xl[((i_hc_2 * 16) + i_14)])); + } + } + #pragma unroll + for (int i_15 = 0; i_15 < 4; ++i_15) { + float4 __11; + float4 v__9 = *(float4*)(sumsq_per_pos + (i_15 * 4)); + float4 __12; + float4 v__10 = *(float4*)(ol + (i_15 * 4)); + __12.x = (v__10.x*v__10.x); + __12.y = (v__10.y*v__10.y); + __12.z = (v__10.z*v__10.z); + __12.w = (v__10.w*v__10.w); + __11.x = (v__9.x+__12.x); + __11.y = (v__9.y+__12.y); + __11.z = (v__9.z+__12.z); + __11.w = (v__9.w+__12.w); + *(float4*)(sumsq_per_pos + (i_15 * 4)) = __11; + uint2 __13; + float4 v__11 = *(float4*)(ol + (i_15 * 4)); + (reinterpret_cast<__nv_bfloat162*>(&__13))[0] = __float22bfloat162_rn(((float2*)(&v__11))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__13))[1] = __float22bfloat162_rn(((float2*)(&v__11))[1]); + *(uint2*)(((bfloat16_t*)buf_dyn_shmem) + (((((i_15 >> 1) * 512) + (((int)threadIdx.x) * 8)) + ((i_15 & 1) * 4)) + 11056)) = __13; + } + sumsq[0] = 0x0p+0f/*0.000000e+00*/; + #pragma unroll + for (int rv = 0; rv < 16; ++rv) { + sumsq[0] = (sumsq[0] + sumsq_per_pos[(((rv & 1) * 8) + (rv >> 1))]); + } + tl::__sync_thread_partial<3, 64>(); + sumsq[0] = tl::AllReduce>::run(sumsq[0], (&(((float*)buf_dyn_shmem)[7192]))); + rsqrt_norm[0] = rsqrtf(((sumsq[0] / 0x1p+12f/*4.096000e+03*/) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + #pragma unroll + for (int i_16 = 0; i_16 < 2; ++i_16) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[(((i_16 * 512) + (((int)threadIdx.x) * 8)) + 12080)])), (&(norm_weight[(((i_16 * 512) + (((int)threadIdx.x) * 8)) - 256)]))); + } + tl::cp_async_commit(); + #pragma unroll + for (int i_17 = 0; i_17 < 2; ++i_17) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[(((i_17 * 512) + (((int)threadIdx.x) * 8)) + 13104)])), (&(norm_weight[(((i_17 * 512) + (((int)threadIdx.x) * 8)) + 768)]))); + } + tl::cp_async_commit(); + for (int i0_h_1 = 0; i0_h_1 < 2; ++i0_h_1) { + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_18 = 0; i_18 < 2; ++i_18) { + *(uint4*)(w_shared_local_cast_3 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + ((((i0_h_1 * 1024) + (i_18 * 512)) + (((int)threadIdx.x) * 8)) + 12080)); + for (int vec_3 = 0; vec_3 < 2; ++vec_3) { + float4 __14; + uint2 v__12 = *(uint2*)(w_shared_local_cast_3 + (vec_3 * 4)); + ((float2*)(&__14))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__12))[0]); + ((float2*)(&__14))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__12))[1]); + *(float4*)(w_local + ((i_18 * 8) + (vec_3 * 4))) = __14; + } + } + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_19 = 0; i_19 < 2; ++i_19) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i0_h_1 * 1024) + (i_19 * 512)) + (((int)threadIdx.x) * 8)) + 12080)])), (&(norm_weight[((((i0_h_1 * 1024) + (i_19 * 512)) + (((int)threadIdx.x) * 8)) + 1792)]))); + } + tl::cp_async_commit(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_20 = 0; i_20 < 2; ++i_20) { + *(uint4*)(output_shared_local_cast_4 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + ((((i0_h_1 * 1024) + (i_20 * 512)) + (((int)threadIdx.x) * 8)) + 7984)); + for (int vec_4 = 0; vec_4 < 2; ++vec_4) { + float4 __15; + float4 __16; + float4 __17; + uint2 v__13 = *(uint2*)(output_shared_local_cast_4 + (vec_4 * 4)); + ((float2*)(&__17))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__13))[0]); + ((float2*)(&__17))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__13))[1]); + float4 v__14 = make_float4(rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0]); + __16.x = (__17.x*v__14.x); + __16.y = (__17.y*v__14.y); + __16.z = (__17.z*v__14.z); + __16.w = (__17.w*v__14.w); + float4 v__15 = *(float4*)(w_local + ((i_20 * 8) + (vec_4 * 4))); + __15.x = (__16.x*v__15.x); + __15.y = (__16.y*v__15.y); + __15.z = (__16.z*v__15.z); + __15.w = (__16.w*v__15.w); + *(float4*)(ol_1 + ((i_20 * 8) + (vec_4 * 4))) = __15; + } + } + #pragma unroll + for (int i_21 = 0; i_21 < 2; ++i_21) { + for (int vec_5 = 0; vec_5 < 2; ++vec_5) { + uint2 __18; + float4 v__16 = *(float4*)(ol_1 + ((i_21 * 8) + (vec_5 * 4))); + (reinterpret_cast<__nv_bfloat162*>(&__18))[0] = __float22bfloat162_rn(((float2*)(&v__16))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__18))[1] = __float22bfloat162_rn(((float2*)(&v__16))[1]); + *(uint2*)(layer_input_local_cast_5 + (vec_5 * 4)) = __18; + } + *(uint4*)(layer_input + (((((((int64_t)((int)blockIdx.x)) * (int64_t)4096) + (((int64_t)i0_h_1) * (int64_t)1024)) + (((int64_t)i_21) * (int64_t)512)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8)) - (int64_t)256)) = *(uint4*)(layer_input_local_cast_5 + 0); + } + } + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_22 = 0; i_22 < 2; ++i_22) { + *(uint4*)(w_shared_local_cast_6 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_22 * 512) + (((int)threadIdx.x) * 8)) + 12080)); + for (int vec_6 = 0; vec_6 < 2; ++vec_6) { + float4 __19; + uint2 v__17 = *(uint2*)(w_shared_local_cast_6 + (vec_6 * 4)); + ((float2*)(&__19))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__17))[0]); + ((float2*)(&__19))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__17))[1]); + *(float4*)(w_local + ((i_22 * 8) + (vec_6 * 4))) = __19; + } + } + #pragma unroll + for (int i_23 = 0; i_23 < 2; ++i_23) { + *(uint4*)(output_shared_local_cast_7 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_23 * 512) + (((int)threadIdx.x) * 8)) + 10032)); + for (int vec_7 = 0; vec_7 < 2; ++vec_7) { + float4 __20; + float4 __21; + float4 __22; + uint2 v__18 = *(uint2*)(output_shared_local_cast_7 + (vec_7 * 4)); + ((float2*)(&__22))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__18))[0]); + ((float2*)(&__22))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__18))[1]); + float4 v__19 = make_float4(rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0]); + __21.x = (__22.x*v__19.x); + __21.y = (__22.y*v__19.y); + __21.z = (__22.z*v__19.z); + __21.w = (__22.w*v__19.w); + float4 v__20 = *(float4*)(w_local + ((i_23 * 8) + (vec_7 * 4))); + __20.x = (__21.x*v__20.x); + __20.y = (__21.y*v__20.y); + __20.z = (__21.z*v__20.z); + __20.w = (__21.w*v__20.w); + *(float4*)(ol_1 + ((i_23 * 8) + (vec_7 * 4))) = __20; + } + } + #pragma unroll + for (int i_24 = 0; i_24 < 2; ++i_24) { + for (int vec_8 = 0; vec_8 < 2; ++vec_8) { + uint2 __23; + float4 v__21 = *(float4*)(ol_1 + ((i_24 * 8) + (vec_8 * 4))); + (reinterpret_cast<__nv_bfloat162*>(&__23))[0] = __float22bfloat162_rn(((float2*)(&v__21))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__23))[1] = __float22bfloat162_rn(((float2*)(&v__21))[1]); + *(uint2*)(layer_input_local_cast_8 + (vec_8 * 4)) = __23; + } + *(uint4*)(layer_input + ((((((int64_t)((int)blockIdx.x)) * (int64_t)4096) + (((int64_t)i_24) * (int64_t)512)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8)) + (int64_t)1792)) = *(uint4*)(layer_input_local_cast_8 + 0); + } + tl::cp_async_wait<0>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_25 = 0; i_25 < 2; ++i_25) { + *(uint4*)(w_shared_local_cast_9 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_25 * 512) + (((int)threadIdx.x) * 8)) + 13104)); + for (int vec_9 = 0; vec_9 < 2; ++vec_9) { + float4 __24; + uint2 v__22 = *(uint2*)(w_shared_local_cast_9 + (vec_9 * 4)); + ((float2*)(&__24))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__22))[0]); + ((float2*)(&__24))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__22))[1]); + *(float4*)(w_local + ((i_25 * 8) + (vec_9 * 4))) = __24; + } + } + #pragma unroll + for (int i_26 = 0; i_26 < 2; ++i_26) { + *(uint4*)(output_shared_local_cast_10 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_26 * 512) + (((int)threadIdx.x) * 8)) + 11056)); + for (int vec_10 = 0; vec_10 < 2; ++vec_10) { + float4 __25; + float4 __26; + float4 __27; + uint2 v__23 = *(uint2*)(output_shared_local_cast_10 + (vec_10 * 4)); + ((float2*)(&__27))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__23))[0]); + ((float2*)(&__27))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__23))[1]); + float4 v__24 = make_float4(rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0]); + __26.x = (__27.x*v__24.x); + __26.y = (__27.y*v__24.y); + __26.z = (__27.z*v__24.z); + __26.w = (__27.w*v__24.w); + float4 v__25 = *(float4*)(w_local + ((i_26 * 8) + (vec_10 * 4))); + __25.x = (__26.x*v__25.x); + __25.y = (__26.y*v__25.y); + __25.z = (__26.z*v__25.z); + __25.w = (__26.w*v__25.w); + *(float4*)(ol_1 + ((i_26 * 8) + (vec_10 * 4))) = __25; + } + } + #pragma unroll + for (int i_27 = 0; i_27 < 2; ++i_27) { + for (int vec_11 = 0; vec_11 < 2; ++vec_11) { + uint2 __28; + float4 v__26 = *(float4*)(ol_1 + ((i_27 * 8) + (vec_11 * 4))); + (reinterpret_cast<__nv_bfloat162*>(&__28))[0] = __float22bfloat162_rn(((float2*)(&v__26))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__28))[1] = __float22bfloat162_rn(((float2*)(&v__26))[1]); + *(uint2*)(layer_input_local_cast_11 + (vec_11 * 4)) = __28; + } + *(uint4*)(layer_input + ((((((int64_t)((int)blockIdx.x)) * (int64_t)4096) + (((int64_t)i_27) * (int64_t)512)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8)) + (int64_t)2816)) = *(uint4*)(layer_input_local_cast_11 + 0); + } + } + cudaTriggerProgrammaticLaunchCompletion(); +} + diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/690cfe1726579f52e2028c161d3001b9f82af97555a40aab825d6e0140ad4e12/host_kernel.cu b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/690cfe1726579f52e2028c161d3001b9f82af97555a40aab825d6e0140ad4e12/host_kernel.cu new file mode 100644 index 0000000..e72b9ff --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/690cfe1726579f52e2028c161d3001b9f82af97555a40aab825d6e0140ad4e12/host_kernel.cu @@ -0,0 +1,3289 @@ +// tilelang target: c -keys=cpu +#define TVM_EXPORTS +#include "tvm/runtime/base.h" +#include "tvm/runtime/c_backend_api.h" +#include "tvm/ffi/c_api.h" +#include +#include +#include +#ifdef __OBJC__ +#include "tvm/runtime/device_api.h" +#include "tvm/ffi/function.h" +#include +#include +#include +#endif +void* __tvm_ffi__library_ctx = NULL; +static void* __tvm_error_ndim_mismatch_packed = NULL; +static void* __tvm_error_dtype_mismatch_packed = NULL; +static void* __tvm_error_expect_eq_packed = NULL; +static void* __tvm_error_constraint_violation_packed = NULL; +static void* __tvm_error_byte_offset_mismatch_packed = NULL; +static void* __tvm_error_device_type_mismatch_packed = NULL; +static void* __tvm_error_null_ptr_packed = NULL; +static void* __tvm_set_device_packed = NULL; +static void* mhc_pre_big_fuse_with_norm_tilelang_kernel_packed = NULL; +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_mhc_pre_big_fuse_with_norm_tilelang(void* self_handle, void* args, int32_t num_args, void* result); +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_mhc_pre_big_fuse_with_norm_tilelang(void* self_handle, void* args, int32_t num_args, void* result) { + __attribute__((aligned(64))) TVMFFIAny stack[16]; + void* stack_ffi_any = stack; + if (!((num_args == 9))) { + char __tvm_assert_msg_buf[512]; + snprintf(__tvm_assert_msg_buf, 512, "%s; expected: %lld, got: %lld", "mhc_pre_big_fuse_with_norm_tilelang: num_args should be 9", (long long)(num_args), (long long)(9)); + TVMFFIErrorSetRaisedFromCStr("RuntimeError", __tvm_assert_msg_buf); + return -1; + } + if (!(!(args == NULL))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang: args pointer is NULL"); + return -1; + } + int32_t gemm_out_mul_type_index = (((TVMFFIAny*)args)[0].type_index); + if (!(((((gemm_out_mul_type_index == 0) || (gemm_out_mul_type_index == 4)) || (gemm_out_mul_type_index == 7)) || (64 <= gemm_out_mul_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input gemm_out_mul expected pointer or tensor handle"); + return -1; + } + int32_t gemm_out_sqrsum_type_index = (((TVMFFIAny*)args)[1].type_index); + if (!(((((gemm_out_sqrsum_type_index == 0) || (gemm_out_sqrsum_type_index == 4)) || (gemm_out_sqrsum_type_index == 7)) || (64 <= gemm_out_sqrsum_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input gemm_out_sqrsum expected pointer or tensor handle"); + return -1; + } + int32_t hc_scale_type_index = (((TVMFFIAny*)args)[2].type_index); + if (!(((((hc_scale_type_index == 0) || (hc_scale_type_index == 4)) || (hc_scale_type_index == 7)) || (64 <= hc_scale_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input hc_scale expected pointer or tensor handle"); + return -1; + } + int32_t hc_base_type_index = (((TVMFFIAny*)args)[3].type_index); + if (!(((((hc_base_type_index == 0) || (hc_base_type_index == 4)) || (hc_base_type_index == 7)) || (64 <= hc_base_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input hc_base expected pointer or tensor handle"); + return -1; + } + int32_t residual_type_index = (((TVMFFIAny*)args)[4].type_index); + if (!(((((residual_type_index == 0) || (residual_type_index == 4)) || (residual_type_index == 7)) || (64 <= residual_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input residual expected pointer or tensor handle"); + return -1; + } + int32_t post_mix_type_index = (((TVMFFIAny*)args)[5].type_index); + if (!(((((post_mix_type_index == 0) || (post_mix_type_index == 4)) || (post_mix_type_index == 7)) || (64 <= post_mix_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input post_mix expected pointer or tensor handle"); + return -1; + } + int32_t comb_mix_type_index = (((TVMFFIAny*)args)[6].type_index); + if (!(((((comb_mix_type_index == 0) || (comb_mix_type_index == 4)) || (comb_mix_type_index == 7)) || (64 <= comb_mix_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input comb_mix expected pointer or tensor handle"); + return -1; + } + int32_t layer_input_type_index = (((TVMFFIAny*)args)[7].type_index); + if (!(((((layer_input_type_index == 0) || (layer_input_type_index == 4)) || (layer_input_type_index == 7)) || (64 <= layer_input_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input layer_input expected pointer or tensor handle"); + return -1; + } + int32_t norm_weight_type_index = (((TVMFFIAny*)args)[8].type_index); + if (!(((((norm_weight_type_index == 0) || (norm_weight_type_index == 4)) || (norm_weight_type_index == 7)) || (64 <= norm_weight_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input norm_weight expected pointer or tensor handle"); + return -1; + } + void* gemm_out_mul = ((gemm_out_mul_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[0].v_ptr) + 24)) : (((TVMFFIAny*)args)[0].v_ptr)); + void* gemm_out_sqrsum = ((gemm_out_sqrsum_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[1].v_ptr) + 24)) : (((TVMFFIAny*)args)[1].v_ptr)); + void* hc_scale = ((hc_scale_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[2].v_ptr) + 24)) : (((TVMFFIAny*)args)[2].v_ptr)); + void* hc_base = ((hc_base_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[3].v_ptr) + 24)) : (((TVMFFIAny*)args)[3].v_ptr)); + void* residual = ((residual_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[4].v_ptr) + 24)) : (((TVMFFIAny*)args)[4].v_ptr)); + void* post_mix = ((post_mix_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[5].v_ptr) + 24)) : (((TVMFFIAny*)args)[5].v_ptr)); + void* comb_mix = ((comb_mix_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[6].v_ptr) + 24)) : (((TVMFFIAny*)args)[6].v_ptr)); + void* layer_input = ((layer_input_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[7].v_ptr) + 24)) : (((TVMFFIAny*)args)[7].v_ptr)); + void* norm_weight = ((norm_weight_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[8].v_ptr) + 24)) : (((TVMFFIAny*)args)[8].v_ptr)); + bool mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_is_null = (gemm_out_mul == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.gemm_out_mul is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_is_null = (gemm_out_sqrsum == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.gemm_out_sqrsum is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_hc_scale_is_null = (hc_scale == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_hc_scale_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.hc_scale is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_hc_base_is_null = (hc_base == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_hc_base_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.hc_base is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_residual_is_null = (residual == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_residual_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.residual is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_post_mix_is_null = (post_mix == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_post_mix_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.post_mix is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_comb_mix_is_null = (comb_mix == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_comb_mix_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.comb_mix is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_layer_input_is_null = (layer_input == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_layer_input_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.layer_input is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_norm_weight_is_null = (norm_weight == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_norm_weight_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.norm_weight is expected to have non-NULL pointer"); + return -1; + } + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape = (((DLTensor*)gemm_out_mul)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape = (((DLTensor*)gemm_out_sqrsum)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_hc_scale_shape = (((DLTensor*)hc_scale)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_hc_base_shape = (((DLTensor*)hc_base)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_residual_shape = (((DLTensor*)residual)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape = (((DLTensor*)post_mix)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape = (((DLTensor*)comb_mix)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape = (((DLTensor*)layer_input)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_norm_weight_shape = (((DLTensor*)norm_weight)[0].shape); + if ((((DLTensor*)gemm_out_mul)[0].ndim) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_1; + result_1.type_index = kTVMFFINone; + result_1.zero_padding = 0; + result_1.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_1) != 0) { + return -1; + } + } + if (!((bool)1)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "Symbolic shape variable num_tokens requires at least one non-null buffer among: mhc_pre_big_fuse_with_norm_tilelang.gemm_out_mul, mhc_pre_big_fuse_with_norm_tilelang.gemm_out_sqrsum, mhc_pre_big_fuse_with_norm_tilelang.residual, mhc_pre_big_fuse_with_norm_tilelang.post_mix, mhc_pre_big_fuse_with_norm_tilelang.comb_mix, mhc_pre_big_fuse_with_norm_tilelang.layer_input"); + return -1; + } + int32_t num_tokens = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]); + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides = (((DLTensor*)gemm_out_mul)[0].strides); + int32_t dev_id = (((DLTensor*)gemm_out_mul)[0].device.device_id); + void* gemm_out_mul_1 = (((DLTensor*)gemm_out_mul)[0].data); + if ((((DLTensor*)gemm_out_sqrsum)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_2; + result_2.type_index = kTVMFFINone; + result_2.zero_padding = 0; + result_2.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_2) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides = (((DLTensor*)gemm_out_sqrsum)[0].strides); + void* gemm_out_sqrsum_1 = (((DLTensor*)gemm_out_sqrsum)[0].data); + if ((((DLTensor*)hc_scale)[0].ndim) != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_3; + result_3.type_index = kTVMFFINone; + result_3.zero_padding = 0; + result_3.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_3) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides = (((DLTensor*)hc_scale)[0].strides); + void* hc_scale_1 = (((DLTensor*)hc_scale)[0].data); + if ((((DLTensor*)hc_base)[0].ndim) != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_4; + result_4.type_index = kTVMFFINone; + result_4.zero_padding = 0; + result_4.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_4) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides = (((DLTensor*)hc_base)[0].strides); + void* hc_base_1 = (((DLTensor*)hc_base)[0].data); + if ((((DLTensor*)residual)[0].ndim) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_5; + result_5.type_index = kTVMFFINone; + result_5.zero_padding = 0; + result_5.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_5) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_residual_strides = (((DLTensor*)residual)[0].strides); + void* residual_1 = (((DLTensor*)residual)[0].data); + if ((((DLTensor*)post_mix)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_6; + result_6.type_index = kTVMFFINone; + result_6.zero_padding = 0; + result_6.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_6) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides = (((DLTensor*)post_mix)[0].strides); + void* post_mix_1 = (((DLTensor*)post_mix)[0].data); + if ((((DLTensor*)comb_mix)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_7; + result_7.type_index = kTVMFFINone; + result_7.zero_padding = 0; + result_7.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_7) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides = (((DLTensor*)comb_mix)[0].strides); + void* comb_mix_1 = (((DLTensor*)comb_mix)[0].data); + if ((((DLTensor*)layer_input)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_8; + result_8.type_index = kTVMFFINone; + result_8.zero_padding = 0; + result_8.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_8) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides = (((DLTensor*)layer_input)[0].strides); + void* layer_input_1 = (((DLTensor*)layer_input)[0].data); + if ((((DLTensor*)norm_weight)[0].ndim) != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_9; + result_9.type_index = kTVMFFINone; + result_9.zero_padding = 0; + result_9.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_9) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides = (((DLTensor*)norm_weight)[0].strides); + void* norm_weight_1 = (((DLTensor*)norm_weight)[0].data); + if ((((((DLTensor*)gemm_out_mul)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)gemm_out_mul)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)gemm_out_mul)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_10; + result_10.type_index = kTVMFFINone; + result_10.zero_padding = 0; + result_10.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_10) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[0]) != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_11; + result_11.type_index = kTVMFFINone; + result_11.zero_padding = 0; + result_11.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_11) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[2]) != 24) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)24; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[2])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_12; + result_12.type_index = kTVMFFINone; + result_12.zero_padding = 0; + result_12.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_12) != 0) { + return -1; + } + } + int32_t condval; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval = 1; + } else { + condval = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[2]); + } + if (condval != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_1; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval_1 = 1; + } else { + condval_1 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[2]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_1); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_13; + result_13.type_index = kTVMFFINone; + result_13.zero_padding = 0; + result_13.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_13) != 0) { + return -1; + } + } + int32_t condval_2; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval_2 = 1; + } else { + condval_2 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[1]); + } + if ((condval_2 != 24) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_14; + result_14.type_index = kTVMFFINone; + result_14.zero_padding = 0; + result_14.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_14) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)gemm_out_mul)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_15; + result_15.type_index = kTVMFFINone; + result_15.zero_padding = 0; + result_15.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_15) != 0) { + return -1; + } + } + if ((((DLTensor*)gemm_out_mul)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_16; + result_16.type_index = kTVMFFINone; + result_16.zero_padding = 0; + result_16.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_16) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (gemm_out_mul_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_17; + result_17.type_index = kTVMFFINone; + result_17.zero_padding = 0; + result_17.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_17) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)gemm_out_sqrsum)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)gemm_out_sqrsum)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)gemm_out_sqrsum)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_18; + result_18.type_index = kTVMFFINone; + result_18.zero_padding = 0; + result_18.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_18) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[0]) != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_19; + result_19.type_index = kTVMFFINone; + result_19.zero_padding = 0; + result_19.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_19) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[1])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_20; + result_20.type_index = kTVMFFINone; + result_20.zero_padding = 0; + result_20.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_20) != 0) { + return -1; + } + } + int32_t condval_3; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides == NULL)) { + condval_3 = 1; + } else { + condval_3 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides)[1]); + } + if ((condval_3 != 1) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_21; + result_21.type_index = kTVMFFINone; + result_21.zero_padding = 0; + result_21.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_21) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)gemm_out_sqrsum)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_22; + result_22.type_index = kTVMFFINone; + result_22.zero_padding = 0; + result_22.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_22) != 0) { + return -1; + } + } + if ((((DLTensor*)gemm_out_sqrsum)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_23; + result_23.type_index = kTVMFFINone; + result_23.zero_padding = 0; + result_23.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_23) != 0) { + return -1; + } + } + if ((((DLTensor*)gemm_out_sqrsum)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_24; + result_24.type_index = kTVMFFINone; + result_24.zero_padding = 0; + result_24.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_24) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (gemm_out_sqrsum_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_25; + result_25.type_index = kTVMFFINone; + result_25.zero_padding = 0; + result_25.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_25) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)hc_scale)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)hc_scale)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)hc_scale)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_26; + result_26.type_index = kTVMFFINone; + result_26.zero_padding = 0; + result_26.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_26) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_shape)[0]) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_27; + result_27.type_index = kTVMFFINone; + result_27.zero_padding = 0; + result_27.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_27) != 0) { + return -1; + } + } + int32_t condval_4; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides == NULL)) { + condval_4 = 1; + } else { + condval_4 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides)[0]); + } + if (condval_4 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_5; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides == NULL)) { + condval_5 = 1; + } else { + condval_5 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides)[0]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_5); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_28; + result_28.type_index = kTVMFFINone; + result_28.zero_padding = 0; + result_28.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_28) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)hc_scale)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_29; + result_29.type_index = kTVMFFINone; + result_29.zero_padding = 0; + result_29.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_29) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_scale)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_30; + result_30.type_index = kTVMFFINone; + result_30.zero_padding = 0; + result_30.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_30) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_scale)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_31; + result_31.type_index = kTVMFFINone; + result_31.zero_padding = 0; + result_31.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_31) != 0) { + return -1; + } + } + if (hc_scale_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_32; + result_32.type_index = kTVMFFINone; + result_32.zero_padding = 0; + result_32.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_32) != 0) { + return -1; + } + } + if ((((((DLTensor*)hc_base)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)hc_base)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)hc_base)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_33; + result_33.type_index = kTVMFFINone; + result_33.zero_padding = 0; + result_33.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_33) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_shape)[0]) != 24) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)24; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_34; + result_34.type_index = kTVMFFINone; + result_34.zero_padding = 0; + result_34.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_34) != 0) { + return -1; + } + } + int32_t condval_6; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides == NULL)) { + condval_6 = 1; + } else { + condval_6 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides)[0]); + } + if (condval_6 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_7; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides == NULL)) { + condval_7 = 1; + } else { + condval_7 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides)[0]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_7); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_35; + result_35.type_index = kTVMFFINone; + result_35.zero_padding = 0; + result_35.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_35) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)hc_base)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_36; + result_36.type_index = kTVMFFINone; + result_36.zero_padding = 0; + result_36.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_36) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_base)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_37; + result_37.type_index = kTVMFFINone; + result_37.zero_padding = 0; + result_37.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_37) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_base)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_38; + result_38.type_index = kTVMFFINone; + result_38.zero_padding = 0; + result_38.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_38) != 0) { + return -1; + } + } + if (hc_base_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_39; + result_39.type_index = kTVMFFINone; + result_39.zero_padding = 0; + result_39.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_39) != 0) { + return -1; + } + } + if ((((((DLTensor*)residual)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)residual)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)residual)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)residual)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)residual)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_40; + result_40.type_index = kTVMFFINone; + result_40.zero_padding = 0; + result_40.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_40) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_41; + result_41.type_index = kTVMFFINone; + result_41.zero_padding = 0; + result_41.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_41) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[1]) != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_42; + result_42.type_index = kTVMFFINone; + result_42.zero_padding = 0; + result_42.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_42) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[2]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[2])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_43; + result_43.type_index = kTVMFFINone; + result_43.zero_padding = 0; + result_43.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_43) != 0) { + return -1; + } + } + int32_t condval_8; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_8 = 1; + } else { + condval_8 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[2]); + } + if (condval_8 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_9; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_9 = 1; + } else { + condval_9 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[2]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_9); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_44; + result_44.type_index = kTVMFFINone; + result_44.zero_padding = 0; + result_44.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_44) != 0) { + return -1; + } + } + int32_t condval_10; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_10 = 1; + } else { + condval_10 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[1]); + } + if (condval_10 != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_11; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_11 = 1; + } else { + condval_11 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_11); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_45; + result_45.type_index = kTVMFFINone; + result_45.zero_padding = 0; + result_45.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_45) != 0) { + return -1; + } + } + int32_t condval_12; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_12 = 1; + } else { + condval_12 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[0]); + } + if ((condval_12 != 16384) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_46; + result_46.type_index = kTVMFFINone; + result_46.zero_padding = 0; + result_46.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_46) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)residual)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_47; + result_47.type_index = kTVMFFINone; + result_47.zero_padding = 0; + result_47.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_47) != 0) { + return -1; + } + } + if ((((DLTensor*)residual)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)residual)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_48; + result_48.type_index = kTVMFFINone; + result_48.zero_padding = 0; + result_48.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_48) != 0) { + return -1; + } + } + if ((((DLTensor*)residual)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_49; + result_49.type_index = kTVMFFINone; + result_49.zero_padding = 0; + result_49.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_49) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (residual_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_50; + result_50.type_index = kTVMFFINone; + result_50.zero_padding = 0; + result_50.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_50) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)post_mix)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)post_mix)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)post_mix)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_51; + result_51.type_index = kTVMFFINone; + result_51.zero_padding = 0; + result_51.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_51) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_52; + result_52.type_index = kTVMFFINone; + result_52.zero_padding = 0; + result_52.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_52) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[1]) != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_53; + result_53.type_index = kTVMFFINone; + result_53.zero_padding = 0; + result_53.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_53) != 0) { + return -1; + } + } + int32_t condval_13; + if ((mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides == NULL)) { + condval_13 = 1; + } else { + condval_13 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides)[1]); + } + if (condval_13 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_14; + if ((mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides == NULL)) { + condval_14 = 1; + } else { + condval_14 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_14); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_54; + result_54.type_index = kTVMFFINone; + result_54.zero_padding = 0; + result_54.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_54) != 0) { + return -1; + } + } + int32_t condval_15; + if ((mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides == NULL)) { + condval_15 = 1; + } else { + condval_15 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides)[0]); + } + if ((condval_15 != 4) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_55; + result_55.type_index = kTVMFFINone; + result_55.zero_padding = 0; + result_55.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_55) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)post_mix)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_56; + result_56.type_index = kTVMFFINone; + result_56.zero_padding = 0; + result_56.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_56) != 0) { + return -1; + } + } + if ((((DLTensor*)post_mix)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_57; + result_57.type_index = kTVMFFINone; + result_57.zero_padding = 0; + result_57.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_57) != 0) { + return -1; + } + } + if ((((DLTensor*)post_mix)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_58; + result_58.type_index = kTVMFFINone; + result_58.zero_padding = 0; + result_58.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_58) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (post_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_59; + result_59.type_index = kTVMFFINone; + result_59.zero_padding = 0; + result_59.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_59) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)comb_mix)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)comb_mix)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)comb_mix)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_60; + result_60.type_index = kTVMFFINone; + result_60.zero_padding = 0; + result_60.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_60) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_61; + result_61.type_index = kTVMFFINone; + result_61.zero_padding = 0; + result_61.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_61) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[1]) != 16) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_62; + result_62.type_index = kTVMFFINone; + result_62.zero_padding = 0; + result_62.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_62) != 0) { + return -1; + } + } + int32_t condval_16; + if ((mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides == NULL)) { + condval_16 = 1; + } else { + condval_16 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides)[1]); + } + if (condval_16 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_17; + if ((mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides == NULL)) { + condval_17 = 1; + } else { + condval_17 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_17); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_63; + result_63.type_index = kTVMFFINone; + result_63.zero_padding = 0; + result_63.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_63) != 0) { + return -1; + } + } + int32_t condval_18; + if ((mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides == NULL)) { + condval_18 = 1; + } else { + condval_18 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides)[0]); + } + if ((condval_18 != 16) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_64; + result_64.type_index = kTVMFFINone; + result_64.zero_padding = 0; + result_64.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_64) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)comb_mix)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_65; + result_65.type_index = kTVMFFINone; + result_65.zero_padding = 0; + result_65.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_65) != 0) { + return -1; + } + } + if ((((DLTensor*)comb_mix)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_66; + result_66.type_index = kTVMFFINone; + result_66.zero_padding = 0; + result_66.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_66) != 0) { + return -1; + } + } + if ((((DLTensor*)comb_mix)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_67; + result_67.type_index = kTVMFFINone; + result_67.zero_padding = 0; + result_67.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_67) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (comb_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_68; + result_68.type_index = kTVMFFINone; + result_68.zero_padding = 0; + result_68.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_68) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)layer_input)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)layer_input)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)layer_input)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_69; + result_69.type_index = kTVMFFINone; + result_69.zero_padding = 0; + result_69.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_69) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_70; + result_70.type_index = kTVMFFINone; + result_70.zero_padding = 0; + result_70.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_70) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[1]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_71; + result_71.type_index = kTVMFFINone; + result_71.zero_padding = 0; + result_71.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_71) != 0) { + return -1; + } + } + int32_t condval_19; + if ((mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides == NULL)) { + condval_19 = 1; + } else { + condval_19 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides)[1]); + } + if (condval_19 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_20; + if ((mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides == NULL)) { + condval_20 = 1; + } else { + condval_20 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_20); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_72; + result_72.type_index = kTVMFFINone; + result_72.zero_padding = 0; + result_72.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_72) != 0) { + return -1; + } + } + int32_t condval_21; + if ((mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides == NULL)) { + condval_21 = 1; + } else { + condval_21 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides)[0]); + } + if ((condval_21 != 4096) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_73; + result_73.type_index = kTVMFFINone; + result_73.zero_padding = 0; + result_73.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_73) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)layer_input)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_74; + result_74.type_index = kTVMFFINone; + result_74.zero_padding = 0; + result_74.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_74) != 0) { + return -1; + } + } + if ((((DLTensor*)layer_input)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_75; + result_75.type_index = kTVMFFINone; + result_75.zero_padding = 0; + result_75.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_75) != 0) { + return -1; + } + } + if ((((DLTensor*)layer_input)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_76; + result_76.type_index = kTVMFFINone; + result_76.zero_padding = 0; + result_76.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_76) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (layer_input_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_77; + result_77.type_index = kTVMFFINone; + result_77.zero_padding = 0; + result_77.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_77) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)norm_weight)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)norm_weight)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)norm_weight)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_78; + result_78.type_index = kTVMFFINone; + result_78.zero_padding = 0; + result_78.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_78) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_shape)[0]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_79; + result_79.type_index = kTVMFFINone; + result_79.zero_padding = 0; + result_79.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_79) != 0) { + return -1; + } + } + int32_t condval_22; + if ((mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides == NULL)) { + condval_22 = 1; + } else { + condval_22 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides)[0]); + } + if (condval_22 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_23; + if ((mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides == NULL)) { + condval_23 = 1; + } else { + condval_23 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides)[0]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_23); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_80; + result_80.type_index = kTVMFFINone; + result_80.zero_padding = 0; + result_80.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_80) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)norm_weight)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_81; + result_81.type_index = kTVMFFINone; + result_81.zero_padding = 0; + result_81.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_81) != 0) { + return -1; + } + } + if ((((DLTensor*)norm_weight)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_82; + result_82.type_index = kTVMFFINone; + result_82.zero_padding = 0; + result_82.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_82) != 0) { + return -1; + } + } + if ((((DLTensor*)norm_weight)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_83; + result_83.type_index = kTVMFFINone; + result_83.zero_padding = 0; + result_83.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_83) != 0) { + return -1; + } + } + if (norm_weight_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_84; + result_84.type_index = kTVMFFINone; + result_84.zero_padding = 0; + result_84.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_84) != 0) { + return -1; + } + } + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = ((int64_t)2); + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = ((int64_t)dev_id); + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + if (__tvm_set_device_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_set_device", &__tvm_set_device_packed) != 0) { + return -1; + } + } + TVMFFIAny result_85; + result_85.type_index = kTVMFFINone; + result_85.zero_padding = 0; + result_85.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_set_device_packed, (TVMFFIAny*) stack_ffi_any, 2, &result_85) != 0) { + return -1; + } + if (comb_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = comb_mix_1; + if (gemm_out_mul_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = gemm_out_mul_1; + if (gemm_out_sqrsum_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = gemm_out_sqrsum_1; + if (hc_base_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_ptr) = hc_base_1; + if (hc_scale_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_ptr) = hc_scale_1; + if (layer_input_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_ptr) = layer_input_1; + if (norm_weight_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_ptr) = norm_weight_1; + if (post_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_ptr) = post_mix_1; + if (residual_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_ptr) = residual_1; + (((TVMFFIAny*)stack_ffi_any)[9].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[9].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[9].v_int64) = ((int64_t)num_tokens); + (((TVMFFIAny*)stack_ffi_any)[10].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[10].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[10].v_int64) = ((int64_t)num_tokens); + (((TVMFFIAny*)stack_ffi_any)[11].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[11].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[11].v_int64) = ((int64_t)96); + (((TVMFFIAny*)stack_ffi_any)[12].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[12].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[12].v_int64) = ((int64_t)1); + (((TVMFFIAny*)stack_ffi_any)[13].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[13].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[13].v_int64) = ((int64_t)1); + (((TVMFFIAny*)stack_ffi_any)[14].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[14].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[14].v_int64) = ((int64_t)29040); + (((TVMFFIAny*)stack_ffi_any)[15].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[15].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[15].v_int64) = (int64_t)0; + if (mhc_pre_big_fuse_with_norm_tilelang_kernel_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "mhc_pre_big_fuse_with_norm_tilelang_kernel", &mhc_pre_big_fuse_with_norm_tilelang_kernel_packed) != 0) { + return -1; + } + } + TVMFFIAny result_86; + result_86.type_index = kTVMFFINone; + result_86.zero_padding = 0; + result_86.v_int64 = 0; + if (TVMFFIFunctionCall(mhc_pre_big_fuse_with_norm_tilelang_kernel_packed, (TVMFFIAny*) stack_ffi_any, 15, &result_86) != 0) { + return -1; + } + return 0; +} + +// CodegenC: NOTE: Auto-generated entry function +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_main(void* self, void* args,int num_args, void* result) { + return __tvm_ffi_mhc_pre_big_fuse_with_norm_tilelang(self, args, num_args, result); +} diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/690cfe1726579f52e2028c161d3001b9f82af97555a40aab825d6e0140ad4e12/params.pkl b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/690cfe1726579f52e2028c161d3001b9f82af97555a40aab825d6e0140ad4e12/params.pkl new file mode 100644 index 0000000..e42f0d4 Binary files /dev/null and b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/690cfe1726579f52e2028c161d3001b9f82af97555a40aab825d6e0140ad4e12/params.pkl differ diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/8ac26e5a6bf2572ea507280b0cfe38c49999af7cb683ccecde6888c37a6e6f3a/device_kernel.cu b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/8ac26e5a6bf2572ea507280b0cfe38c49999af7cb683ccecde6888c37a6e6f3a/device_kernel.cu new file mode 100644 index 0000000..918dcd7 --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/8ac26e5a6bf2572ea507280b0cfe38c49999af7cb683ccecde6888c37a6e6f3a/device_kernel.cu @@ -0,0 +1,424 @@ +#include +#include +#include +#include +#include +#include +#include +#ifdef ENABLE_BF16 +#include +#endif + +extern "C" __global__ void mhc_pre_big_fuse_with_norm_tilelang_kernel(float* comb_mix, const float* gemm_out_mul, const float* gemm_out_sqrsum, const float* hc_base, const float* hc_scale, bfloat16_t* layer_input, const bfloat16_t* norm_weight, float* post_mix, const bfloat16_t* residual, int num_tokens); +extern "C" __global__ void __launch_bounds__(96, 1) mhc_pre_big_fuse_with_norm_tilelang_kernel(float* comb_mix, const float* gemm_out_mul, const float* gemm_out_sqrsum, const float* hc_base, const float* hc_scale, bfloat16_t* layer_input, const bfloat16_t* norm_weight, float* post_mix, const bfloat16_t* residual, int num_tokens) { + extern __shared__ __align__(1024) uchar buf_dyn_shmem[]; + float mixes[1]; + float rms[1]; + float cm[1]; + float row_max[1]; + float row_sum[1]; + float col_sum[1]; + float sumsq_per_pos[16]; + float sumsq[1]; + float rsqrt_norm[1]; + float xl[64]; + float ol[16]; + bfloat16_t xs_local_cast[8]; + bfloat16_t xs_local_cast_1[8]; + bfloat16_t xs_local_cast_2[8]; + float w_local[16]; + float ol_1[16]; + bfloat16_t w_shared_local_cast_3[8]; + bfloat16_t output_shared_local_cast_4[8]; + bfloat16_t layer_input_local_cast_5[8]; + bfloat16_t w_shared_local_cast_6[8]; + bfloat16_t output_shared_local_cast_7[8]; + bfloat16_t layer_input_local_cast_8[8]; + bfloat16_t w_shared_local_cast_9[8]; + bfloat16_t output_shared_local_cast_10[8]; + bfloat16_t layer_input_local_cast_11[8]; + mixes[0] = 0x0p+0f/*0.000000e+00*/; + rms[0] = 0x0p+0f/*0.000000e+00*/; + cudaGridDependencySynchronize(); + for (int i_split = 0; i_split < 5; ++i_split) { + rms[0] = (rms[0] + gemm_out_sqrsum[((((int64_t)i_split) * ((int64_t)num_tokens)) + ((int64_t)((int)blockIdx.x)))]); + } + rms[0] = rsqrtf(((rms[0] / 0x1p+14f/*1.638400e+04*/) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + mixes[0] = 0x0p+0f/*0.000000e+00*/; + for (int i_split_1 = 0; i_split_1 < 5; ++i_split_1) { + mixes[0] = (mixes[0] + gemm_out_mul[(((((int64_t)((int)blockIdx.x)) * (int64_t)24) + ((((int64_t)i_split_1) * ((int64_t)num_tokens)) * (int64_t)24)) + (((int64_t)((int)threadIdx.x)) % (int64_t)24))]); + } + mixes[0] = (mixes[0] * rms[0]); + if ((((int)threadIdx.x) / 24) == 0) { + ((float*)buf_dyn_shmem)[(((int)threadIdx.x) % 24)] = mixes[0]; + } + __syncthreads(); + if (((int)threadIdx.x) < 32) { + if (((int)threadIdx.x) < 4) { + post_mix[((((int64_t)((int)blockIdx.x)) * (int64_t)4) + ((int64_t)((int)threadIdx.x)))] = ((0x1p+0f/*1.000000e+00*/ / (0x1p+0f/*1.000000e+00*/ + expf((0x0p+0f/*0.000000e+00*/ - ((((float*)buf_dyn_shmem)[(((int)threadIdx.x) + 4)] * hc_scale[1]) + hc_base[(((int)threadIdx.x) + 4)]))))) * 0x1p+1f/*2.000000e+00*/); + } + cm[0] = ((((float*)buf_dyn_shmem)[((((int)threadIdx.x) & 15) + 8)] * hc_scale[2]) + hc_base[((((int)threadIdx.x) & 15) + 8)]); + row_max[0] = -CUDART_INF_F; + row_max[0] = max(row_max[0], cm[0]); + row_max[0] = tl::AllReduce>::run(row_max[0]); + cm[0] = expf((cm[0] - row_max[0])); + row_sum[0] = 0x0p+0f/*0.000000e+00*/; + row_sum[0] = (row_sum[0] + cm[0]); + row_sum[0] = tl::AllReduce>::run(row_sum[0]); + cm[0] = ((cm[0] / row_sum[0]) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/); + col_sum[0] = 0x0p+0f/*0.000000e+00*/; + col_sum[0] = (col_sum[0] + cm[0]); + col_sum[0] = tl::AllReduce>::run(col_sum[0]); + cm[0] = (cm[0] / (col_sum[0] + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + for (int __1 = 0; __1 < 19; ++__1) { + row_sum[0] = 0x0p+0f/*0.000000e+00*/; + row_sum[0] = (row_sum[0] + cm[0]); + row_sum[0] = tl::AllReduce>::run(row_sum[0]); + cm[0] = (cm[0] / (row_sum[0] + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + col_sum[0] = 0x0p+0f/*0.000000e+00*/; + col_sum[0] = (col_sum[0] + cm[0]); + col_sum[0] = tl::AllReduce>::run(col_sum[0]); + cm[0] = (cm[0] / (col_sum[0] + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + } + if ((((int)threadIdx.x) >> 4) == 0) { + comb_mix[((((int64_t)((int)blockIdx.x)) * (int64_t)16) + (((int64_t)((int)threadIdx.x)) & (int64_t)15))] = cm[0]; + } + } else { + if (((int)threadIdx.x) < 36) { + ((float*)buf_dyn_shmem)[(((int)threadIdx.x) + 7224)] = ((0x1p+0f/*1.000000e+00*/ / (0x1p+0f/*1.000000e+00*/ + expf((0x0p+0f/*0.000000e+00*/ - ((((float*)buf_dyn_shmem)[(((int)threadIdx.x) - 32)] * hc_scale[0]) + hc_base[(((int)threadIdx.x) - 32)]))))) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/); + } + #pragma unroll + for (int i = 0; i < 4; ++i) { + float broadcast_var = 0x0p+0f/*0.000000e+00*/; + *(float4*)(sumsq_per_pos + (i * 4)) = make_float4(broadcast_var, broadcast_var, broadcast_var, broadcast_var); + } + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_1 = 0; i_1 < 8; ++i_1) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i_1 >> 1) * 1024) + (((((i_1 * 64) + ((int)threadIdx.x)) + 96) & 127) * 8)) + 48)])), (&(residual[(((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + ((((int64_t)i_1) >> (int64_t)1) * (int64_t)4096)) + (((((((int64_t)i_1) * (int64_t)64) + ((int64_t)((int)threadIdx.x))) + (int64_t)96) & (int64_t)127) * (int64_t)8))]))); + } + tl::cp_async_commit(); + #pragma unroll + for (int i_2 = 0; i_2 < 8; ++i_2) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i_2 >> 1) * 1024) + (((((i_2 * 64) + ((int)threadIdx.x)) + 96) & 127) * 8)) + 4144)])), (&(residual[((((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + ((((int64_t)i_2) >> (int64_t)1) * (int64_t)4096)) + (((((((int64_t)i_2) * (int64_t)64) + ((int64_t)((int)threadIdx.x))) + (int64_t)96) & (int64_t)127) * (int64_t)8)) + (int64_t)1024)]))); + } + tl::cp_async_commit(); + for (int i0_h = 0; i0_h < 2; ++i0_h) { + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_3 = 0; i_3 < 8; ++i_3) { + *(uint4*)(xs_local_cast + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + ((((i0_h * 4096) + (i_3 * 512)) + (((int)threadIdx.x) * 8)) - 208)); + for (int vec = 0; vec < 2; ++vec) { + float4 __2; + uint2 v_ = *(uint2*)(xs_local_cast + (vec * 4)); + ((float2*)(&__2))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v_))[0]); + ((float2*)(&__2))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v_))[1]); + *(float4*)(xl + ((i_3 * 8) + (vec * 4))) = __2; + } + } + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_4 = 0; i_4 < 8; ++i_4) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i0_h * 4096) + ((i_4 >> 1) * 1024)) + (((((i_4 * 64) + ((int)threadIdx.x)) + 96) & 127) * 8)) + 48)])), (&(residual[(((((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + ((((int64_t)i_4) >> (int64_t)1) * (int64_t)4096)) + (((int64_t)i0_h) * (int64_t)1024)) + (((((((int64_t)i_4) * (int64_t)64) + ((int64_t)((int)threadIdx.x))) + (int64_t)96) & (int64_t)127) * (int64_t)8)) + (int64_t)2048)]))); + } + tl::cp_async_commit(); + #pragma unroll + for (int i_5 = 0; i_5 < 4; ++i_5) { + float broadcast_var_1 = 0x0p+0f/*0.000000e+00*/; + *(float4*)(ol + (i_5 * 4)) = make_float4(broadcast_var_1, broadcast_var_1, broadcast_var_1, broadcast_var_1); + } + tl::__sync_thread_partial<3, 64>(); + for (int i_hc = 0; i_hc < 4; ++i_hc) { + float pre = ((float*)buf_dyn_shmem)[(i_hc + 7256)]; + #pragma unroll + for (int i_6 = 0; i_6 < 16; ++i_6) { + ol[i_6] = (ol[i_6] + (pre * xl[((i_hc * 16) + i_6)])); + } + } + #pragma unroll + for (int i_7 = 0; i_7 < 4; ++i_7) { + float4 __3; + float4 v__1 = *(float4*)(sumsq_per_pos + (i_7 * 4)); + float4 __4; + float4 v__2 = *(float4*)(ol + (i_7 * 4)); + __4.x = (v__2.x*v__2.x); + __4.y = (v__2.y*v__2.y); + __4.z = (v__2.z*v__2.z); + __4.w = (v__2.w*v__2.w); + __3.x = (v__1.x+__4.x); + __3.y = (v__1.y+__4.y); + __3.z = (v__1.z+__4.z); + __3.w = (v__1.w+__4.w); + *(float4*)(sumsq_per_pos + (i_7 * 4)) = __3; + uint2 __5; + float4 v__3 = *(float4*)(ol + (i_7 * 4)); + (reinterpret_cast<__nv_bfloat162*>(&__5))[0] = __float22bfloat162_rn(((float2*)(&v__3))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__5))[1] = __float22bfloat162_rn(((float2*)(&v__3))[1]); + *(uint2*)(((bfloat16_t*)buf_dyn_shmem) + (((((i0_h * 1024) + ((i_7 >> 1) * 512)) + (((int)threadIdx.x) * 8)) + ((i_7 & 1) * 4)) + 7984)) = __5; + } + } + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_8 = 0; i_8 < 8; ++i_8) { + *(uint4*)(xs_local_cast_1 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_8 * 512) + (((int)threadIdx.x) * 8)) - 208)); + for (int vec_1 = 0; vec_1 < 2; ++vec_1) { + float4 __6; + uint2 v__4 = *(uint2*)(xs_local_cast_1 + (vec_1 * 4)); + ((float2*)(&__6))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__4))[0]); + ((float2*)(&__6))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__4))[1]); + *(float4*)(xl + ((i_8 * 8) + (vec_1 * 4))) = __6; + } + } + #pragma unroll + for (int i_9 = 0; i_9 < 4; ++i_9) { + float broadcast_var_2 = 0x0p+0f/*0.000000e+00*/; + *(float4*)(ol + (i_9 * 4)) = make_float4(broadcast_var_2, broadcast_var_2, broadcast_var_2, broadcast_var_2); + } + for (int i_hc_1 = 0; i_hc_1 < 4; ++i_hc_1) { + float pre_1 = ((float*)buf_dyn_shmem)[(i_hc_1 + 7256)]; + #pragma unroll + for (int i_10 = 0; i_10 < 16; ++i_10) { + ol[i_10] = (ol[i_10] + (pre_1 * xl[((i_hc_1 * 16) + i_10)])); + } + } + #pragma unroll + for (int i_11 = 0; i_11 < 4; ++i_11) { + float4 __7; + float4 v__5 = *(float4*)(sumsq_per_pos + (i_11 * 4)); + float4 __8; + float4 v__6 = *(float4*)(ol + (i_11 * 4)); + __8.x = (v__6.x*v__6.x); + __8.y = (v__6.y*v__6.y); + __8.z = (v__6.z*v__6.z); + __8.w = (v__6.w*v__6.w); + __7.x = (v__5.x+__8.x); + __7.y = (v__5.y+__8.y); + __7.z = (v__5.z+__8.z); + __7.w = (v__5.w+__8.w); + *(float4*)(sumsq_per_pos + (i_11 * 4)) = __7; + uint2 __9; + float4 v__7 = *(float4*)(ol + (i_11 * 4)); + (reinterpret_cast<__nv_bfloat162*>(&__9))[0] = __float22bfloat162_rn(((float2*)(&v__7))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__9))[1] = __float22bfloat162_rn(((float2*)(&v__7))[1]); + *(uint2*)(((bfloat16_t*)buf_dyn_shmem) + (((((i_11 >> 1) * 512) + (((int)threadIdx.x) * 8)) + ((i_11 & 1) * 4)) + 10032)) = __9; + } + tl::cp_async_wait<0>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_12 = 0; i_12 < 8; ++i_12) { + *(uint4*)(xs_local_cast_2 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_12 * 512) + (((int)threadIdx.x) * 8)) + 3888)); + for (int vec_2 = 0; vec_2 < 2; ++vec_2) { + float4 __10; + uint2 v__8 = *(uint2*)(xs_local_cast_2 + (vec_2 * 4)); + ((float2*)(&__10))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__8))[0]); + ((float2*)(&__10))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__8))[1]); + *(float4*)(xl + ((i_12 * 8) + (vec_2 * 4))) = __10; + } + } + #pragma unroll + for (int i_13 = 0; i_13 < 4; ++i_13) { + float broadcast_var_3 = 0x0p+0f/*0.000000e+00*/; + *(float4*)(ol + (i_13 * 4)) = make_float4(broadcast_var_3, broadcast_var_3, broadcast_var_3, broadcast_var_3); + } + for (int i_hc_2 = 0; i_hc_2 < 4; ++i_hc_2) { + float pre_2 = ((float*)buf_dyn_shmem)[(i_hc_2 + 7256)]; + #pragma unroll + for (int i_14 = 0; i_14 < 16; ++i_14) { + ol[i_14] = (ol[i_14] + (pre_2 * xl[((i_hc_2 * 16) + i_14)])); + } + } + #pragma unroll + for (int i_15 = 0; i_15 < 4; ++i_15) { + float4 __11; + float4 v__9 = *(float4*)(sumsq_per_pos + (i_15 * 4)); + float4 __12; + float4 v__10 = *(float4*)(ol + (i_15 * 4)); + __12.x = (v__10.x*v__10.x); + __12.y = (v__10.y*v__10.y); + __12.z = (v__10.z*v__10.z); + __12.w = (v__10.w*v__10.w); + __11.x = (v__9.x+__12.x); + __11.y = (v__9.y+__12.y); + __11.z = (v__9.z+__12.z); + __11.w = (v__9.w+__12.w); + *(float4*)(sumsq_per_pos + (i_15 * 4)) = __11; + uint2 __13; + float4 v__11 = *(float4*)(ol + (i_15 * 4)); + (reinterpret_cast<__nv_bfloat162*>(&__13))[0] = __float22bfloat162_rn(((float2*)(&v__11))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__13))[1] = __float22bfloat162_rn(((float2*)(&v__11))[1]); + *(uint2*)(((bfloat16_t*)buf_dyn_shmem) + (((((i_15 >> 1) * 512) + (((int)threadIdx.x) * 8)) + ((i_15 & 1) * 4)) + 11056)) = __13; + } + sumsq[0] = 0x0p+0f/*0.000000e+00*/; + #pragma unroll + for (int rv = 0; rv < 16; ++rv) { + sumsq[0] = (sumsq[0] + sumsq_per_pos[(((rv & 1) * 8) + (rv >> 1))]); + } + tl::__sync_thread_partial<3, 64>(); + sumsq[0] = tl::AllReduce>::run(sumsq[0], (&(((float*)buf_dyn_shmem)[7192]))); + rsqrt_norm[0] = rsqrtf(((sumsq[0] / 0x1p+12f/*4.096000e+03*/) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + #pragma unroll + for (int i_16 = 0; i_16 < 2; ++i_16) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[(((i_16 * 512) + (((int)threadIdx.x) * 8)) + 12080)])), (&(norm_weight[(((i_16 * 512) + (((int)threadIdx.x) * 8)) - 256)]))); + } + tl::cp_async_commit(); + #pragma unroll + for (int i_17 = 0; i_17 < 2; ++i_17) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[(((i_17 * 512) + (((int)threadIdx.x) * 8)) + 13104)])), (&(norm_weight[(((i_17 * 512) + (((int)threadIdx.x) * 8)) + 768)]))); + } + tl::cp_async_commit(); + for (int i0_h_1 = 0; i0_h_1 < 2; ++i0_h_1) { + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_18 = 0; i_18 < 2; ++i_18) { + *(uint4*)(w_shared_local_cast_3 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + ((((i0_h_1 * 1024) + (i_18 * 512)) + (((int)threadIdx.x) * 8)) + 12080)); + for (int vec_3 = 0; vec_3 < 2; ++vec_3) { + float4 __14; + uint2 v__12 = *(uint2*)(w_shared_local_cast_3 + (vec_3 * 4)); + ((float2*)(&__14))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__12))[0]); + ((float2*)(&__14))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__12))[1]); + *(float4*)(w_local + ((i_18 * 8) + (vec_3 * 4))) = __14; + } + } + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_19 = 0; i_19 < 2; ++i_19) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i0_h_1 * 1024) + (i_19 * 512)) + (((int)threadIdx.x) * 8)) + 12080)])), (&(norm_weight[((((i0_h_1 * 1024) + (i_19 * 512)) + (((int)threadIdx.x) * 8)) + 1792)]))); + } + tl::cp_async_commit(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_20 = 0; i_20 < 2; ++i_20) { + *(uint4*)(output_shared_local_cast_4 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + ((((i0_h_1 * 1024) + (i_20 * 512)) + (((int)threadIdx.x) * 8)) + 7984)); + for (int vec_4 = 0; vec_4 < 2; ++vec_4) { + float4 __15; + float4 __16; + float4 __17; + uint2 v__13 = *(uint2*)(output_shared_local_cast_4 + (vec_4 * 4)); + ((float2*)(&__17))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__13))[0]); + ((float2*)(&__17))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__13))[1]); + float4 v__14 = make_float4(rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0]); + __16.x = (__17.x*v__14.x); + __16.y = (__17.y*v__14.y); + __16.z = (__17.z*v__14.z); + __16.w = (__17.w*v__14.w); + float4 v__15 = *(float4*)(w_local + ((i_20 * 8) + (vec_4 * 4))); + __15.x = (__16.x*v__15.x); + __15.y = (__16.y*v__15.y); + __15.z = (__16.z*v__15.z); + __15.w = (__16.w*v__15.w); + *(float4*)(ol_1 + ((i_20 * 8) + (vec_4 * 4))) = __15; + } + } + #pragma unroll + for (int i_21 = 0; i_21 < 2; ++i_21) { + for (int vec_5 = 0; vec_5 < 2; ++vec_5) { + uint2 __18; + float4 v__16 = *(float4*)(ol_1 + ((i_21 * 8) + (vec_5 * 4))); + (reinterpret_cast<__nv_bfloat162*>(&__18))[0] = __float22bfloat162_rn(((float2*)(&v__16))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__18))[1] = __float22bfloat162_rn(((float2*)(&v__16))[1]); + *(uint2*)(layer_input_local_cast_5 + (vec_5 * 4)) = __18; + } + *(uint4*)(layer_input + (((((((int64_t)((int)blockIdx.x)) * (int64_t)4096) + (((int64_t)i0_h_1) * (int64_t)1024)) + (((int64_t)i_21) * (int64_t)512)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8)) - (int64_t)256)) = *(uint4*)(layer_input_local_cast_5 + 0); + } + } + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_22 = 0; i_22 < 2; ++i_22) { + *(uint4*)(w_shared_local_cast_6 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_22 * 512) + (((int)threadIdx.x) * 8)) + 12080)); + for (int vec_6 = 0; vec_6 < 2; ++vec_6) { + float4 __19; + uint2 v__17 = *(uint2*)(w_shared_local_cast_6 + (vec_6 * 4)); + ((float2*)(&__19))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__17))[0]); + ((float2*)(&__19))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__17))[1]); + *(float4*)(w_local + ((i_22 * 8) + (vec_6 * 4))) = __19; + } + } + #pragma unroll + for (int i_23 = 0; i_23 < 2; ++i_23) { + *(uint4*)(output_shared_local_cast_7 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_23 * 512) + (((int)threadIdx.x) * 8)) + 10032)); + for (int vec_7 = 0; vec_7 < 2; ++vec_7) { + float4 __20; + float4 __21; + float4 __22; + uint2 v__18 = *(uint2*)(output_shared_local_cast_7 + (vec_7 * 4)); + ((float2*)(&__22))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__18))[0]); + ((float2*)(&__22))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__18))[1]); + float4 v__19 = make_float4(rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0]); + __21.x = (__22.x*v__19.x); + __21.y = (__22.y*v__19.y); + __21.z = (__22.z*v__19.z); + __21.w = (__22.w*v__19.w); + float4 v__20 = *(float4*)(w_local + ((i_23 * 8) + (vec_7 * 4))); + __20.x = (__21.x*v__20.x); + __20.y = (__21.y*v__20.y); + __20.z = (__21.z*v__20.z); + __20.w = (__21.w*v__20.w); + *(float4*)(ol_1 + ((i_23 * 8) + (vec_7 * 4))) = __20; + } + } + #pragma unroll + for (int i_24 = 0; i_24 < 2; ++i_24) { + for (int vec_8 = 0; vec_8 < 2; ++vec_8) { + uint2 __23; + float4 v__21 = *(float4*)(ol_1 + ((i_24 * 8) + (vec_8 * 4))); + (reinterpret_cast<__nv_bfloat162*>(&__23))[0] = __float22bfloat162_rn(((float2*)(&v__21))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__23))[1] = __float22bfloat162_rn(((float2*)(&v__21))[1]); + *(uint2*)(layer_input_local_cast_8 + (vec_8 * 4)) = __23; + } + *(uint4*)(layer_input + ((((((int64_t)((int)blockIdx.x)) * (int64_t)4096) + (((int64_t)i_24) * (int64_t)512)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8)) + (int64_t)1792)) = *(uint4*)(layer_input_local_cast_8 + 0); + } + tl::cp_async_wait<0>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_25 = 0; i_25 < 2; ++i_25) { + *(uint4*)(w_shared_local_cast_9 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_25 * 512) + (((int)threadIdx.x) * 8)) + 13104)); + for (int vec_9 = 0; vec_9 < 2; ++vec_9) { + float4 __24; + uint2 v__22 = *(uint2*)(w_shared_local_cast_9 + (vec_9 * 4)); + ((float2*)(&__24))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__22))[0]); + ((float2*)(&__24))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__22))[1]); + *(float4*)(w_local + ((i_25 * 8) + (vec_9 * 4))) = __24; + } + } + #pragma unroll + for (int i_26 = 0; i_26 < 2; ++i_26) { + *(uint4*)(output_shared_local_cast_10 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_26 * 512) + (((int)threadIdx.x) * 8)) + 11056)); + for (int vec_10 = 0; vec_10 < 2; ++vec_10) { + float4 __25; + float4 __26; + float4 __27; + uint2 v__23 = *(uint2*)(output_shared_local_cast_10 + (vec_10 * 4)); + ((float2*)(&__27))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__23))[0]); + ((float2*)(&__27))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__23))[1]); + float4 v__24 = make_float4(rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0]); + __26.x = (__27.x*v__24.x); + __26.y = (__27.y*v__24.y); + __26.z = (__27.z*v__24.z); + __26.w = (__27.w*v__24.w); + float4 v__25 = *(float4*)(w_local + ((i_26 * 8) + (vec_10 * 4))); + __25.x = (__26.x*v__25.x); + __25.y = (__26.y*v__25.y); + __25.z = (__26.z*v__25.z); + __25.w = (__26.w*v__25.w); + *(float4*)(ol_1 + ((i_26 * 8) + (vec_10 * 4))) = __25; + } + } + #pragma unroll + for (int i_27 = 0; i_27 < 2; ++i_27) { + for (int vec_11 = 0; vec_11 < 2; ++vec_11) { + uint2 __28; + float4 v__26 = *(float4*)(ol_1 + ((i_27 * 8) + (vec_11 * 4))); + (reinterpret_cast<__nv_bfloat162*>(&__28))[0] = __float22bfloat162_rn(((float2*)(&v__26))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__28))[1] = __float22bfloat162_rn(((float2*)(&v__26))[1]); + *(uint2*)(layer_input_local_cast_11 + (vec_11 * 4)) = __28; + } + *(uint4*)(layer_input + ((((((int64_t)((int)blockIdx.x)) * (int64_t)4096) + (((int64_t)i_27) * (int64_t)512)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8)) + (int64_t)2816)) = *(uint4*)(layer_input_local_cast_11 + 0); + } + } + cudaTriggerProgrammaticLaunchCompletion(); +} + diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/8ac26e5a6bf2572ea507280b0cfe38c49999af7cb683ccecde6888c37a6e6f3a/host_kernel.cu b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/8ac26e5a6bf2572ea507280b0cfe38c49999af7cb683ccecde6888c37a6e6f3a/host_kernel.cu new file mode 100644 index 0000000..1530b54 --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/8ac26e5a6bf2572ea507280b0cfe38c49999af7cb683ccecde6888c37a6e6f3a/host_kernel.cu @@ -0,0 +1,3359 @@ +// tilelang target: c -keys=cpu +#define TVM_EXPORTS +#include "tvm/runtime/base.h" +#include "tvm/runtime/c_backend_api.h" +#include "tvm/ffi/c_api.h" +#include +#include +#include +#ifdef __OBJC__ +#include "tvm/runtime/device_api.h" +#include "tvm/ffi/function.h" +#include +#include +#include +#endif +void* __tvm_ffi__library_ctx = NULL; +static void* __tvm_error_ndim_mismatch_packed = NULL; +static void* __tvm_error_dtype_mismatch_packed = NULL; +static void* __tvm_error_expect_eq_packed = NULL; +static void* __tvm_error_constraint_violation_packed = NULL; +static void* __tvm_error_byte_offset_mismatch_packed = NULL; +static void* __tvm_error_device_type_mismatch_packed = NULL; +static void* __tvm_error_null_ptr_packed = NULL; +static void* __tvm_set_device_packed = NULL; +static void* mhc_pre_big_fuse_with_norm_tilelang_kernel_packed = NULL; +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_mhc_pre_big_fuse_with_norm_tilelang(void* self_handle, void* args, int32_t num_args, void* result); +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_mhc_pre_big_fuse_with_norm_tilelang(void* self_handle, void* args, int32_t num_args, void* result) { + __attribute__((aligned(64))) TVMFFIAny stack[16]; + void* stack_ffi_any = stack; + if (!((num_args == 9))) { + char __tvm_assert_msg_buf[512]; + snprintf(__tvm_assert_msg_buf, 512, "%s; expected: %lld, got: %lld", "mhc_pre_big_fuse_with_norm_tilelang: num_args should be 9", (long long)(num_args), (long long)(9)); + TVMFFIErrorSetRaisedFromCStr("RuntimeError", __tvm_assert_msg_buf); + return -1; + } + if (!(!(args == NULL))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang: args pointer is NULL"); + return -1; + } + int32_t gemm_out_mul_type_index = (((TVMFFIAny*)args)[0].type_index); + if (!(((((gemm_out_mul_type_index == 0) || (gemm_out_mul_type_index == 4)) || (gemm_out_mul_type_index == 7)) || (64 <= gemm_out_mul_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input gemm_out_mul expected pointer or tensor handle"); + return -1; + } + int32_t gemm_out_sqrsum_type_index = (((TVMFFIAny*)args)[1].type_index); + if (!(((((gemm_out_sqrsum_type_index == 0) || (gemm_out_sqrsum_type_index == 4)) || (gemm_out_sqrsum_type_index == 7)) || (64 <= gemm_out_sqrsum_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input gemm_out_sqrsum expected pointer or tensor handle"); + return -1; + } + int32_t hc_scale_type_index = (((TVMFFIAny*)args)[2].type_index); + if (!(((((hc_scale_type_index == 0) || (hc_scale_type_index == 4)) || (hc_scale_type_index == 7)) || (64 <= hc_scale_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input hc_scale expected pointer or tensor handle"); + return -1; + } + int32_t hc_base_type_index = (((TVMFFIAny*)args)[3].type_index); + if (!(((((hc_base_type_index == 0) || (hc_base_type_index == 4)) || (hc_base_type_index == 7)) || (64 <= hc_base_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input hc_base expected pointer or tensor handle"); + return -1; + } + int32_t residual_type_index = (((TVMFFIAny*)args)[4].type_index); + if (!(((((residual_type_index == 0) || (residual_type_index == 4)) || (residual_type_index == 7)) || (64 <= residual_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input residual expected pointer or tensor handle"); + return -1; + } + int32_t post_mix_type_index = (((TVMFFIAny*)args)[5].type_index); + if (!(((((post_mix_type_index == 0) || (post_mix_type_index == 4)) || (post_mix_type_index == 7)) || (64 <= post_mix_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input post_mix expected pointer or tensor handle"); + return -1; + } + int32_t comb_mix_type_index = (((TVMFFIAny*)args)[6].type_index); + if (!(((((comb_mix_type_index == 0) || (comb_mix_type_index == 4)) || (comb_mix_type_index == 7)) || (64 <= comb_mix_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input comb_mix expected pointer or tensor handle"); + return -1; + } + int32_t layer_input_type_index = (((TVMFFIAny*)args)[7].type_index); + if (!(((((layer_input_type_index == 0) || (layer_input_type_index == 4)) || (layer_input_type_index == 7)) || (64 <= layer_input_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input layer_input expected pointer or tensor handle"); + return -1; + } + int32_t norm_weight_type_index = (((TVMFFIAny*)args)[8].type_index); + if (!(((((norm_weight_type_index == 0) || (norm_weight_type_index == 4)) || (norm_weight_type_index == 7)) || (64 <= norm_weight_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input norm_weight expected pointer or tensor handle"); + return -1; + } + void* gemm_out_mul = ((gemm_out_mul_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[0].v_ptr) + 24)) : (((TVMFFIAny*)args)[0].v_ptr)); + void* gemm_out_sqrsum = ((gemm_out_sqrsum_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[1].v_ptr) + 24)) : (((TVMFFIAny*)args)[1].v_ptr)); + void* hc_scale = ((hc_scale_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[2].v_ptr) + 24)) : (((TVMFFIAny*)args)[2].v_ptr)); + void* hc_base = ((hc_base_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[3].v_ptr) + 24)) : (((TVMFFIAny*)args)[3].v_ptr)); + void* residual = ((residual_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[4].v_ptr) + 24)) : (((TVMFFIAny*)args)[4].v_ptr)); + void* post_mix = ((post_mix_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[5].v_ptr) + 24)) : (((TVMFFIAny*)args)[5].v_ptr)); + void* comb_mix = ((comb_mix_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[6].v_ptr) + 24)) : (((TVMFFIAny*)args)[6].v_ptr)); + void* layer_input = ((layer_input_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[7].v_ptr) + 24)) : (((TVMFFIAny*)args)[7].v_ptr)); + void* norm_weight = ((norm_weight_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[8].v_ptr) + 24)) : (((TVMFFIAny*)args)[8].v_ptr)); + bool mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_is_null = (gemm_out_mul == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.gemm_out_mul is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_is_null = (gemm_out_sqrsum == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.gemm_out_sqrsum is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_hc_scale_is_null = (hc_scale == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_hc_scale_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.hc_scale is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_hc_base_is_null = (hc_base == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_hc_base_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.hc_base is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_residual_is_null = (residual == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_residual_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.residual is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_post_mix_is_null = (post_mix == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_post_mix_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.post_mix is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_comb_mix_is_null = (comb_mix == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_comb_mix_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.comb_mix is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_layer_input_is_null = (layer_input == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_layer_input_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.layer_input is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_norm_weight_is_null = (norm_weight == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_norm_weight_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.norm_weight is expected to have non-NULL pointer"); + return -1; + } + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape = (((DLTensor*)gemm_out_mul)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape = (((DLTensor*)gemm_out_sqrsum)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_hc_scale_shape = (((DLTensor*)hc_scale)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_hc_base_shape = (((DLTensor*)hc_base)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_residual_shape = (((DLTensor*)residual)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape = (((DLTensor*)post_mix)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape = (((DLTensor*)comb_mix)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape = (((DLTensor*)layer_input)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_norm_weight_shape = (((DLTensor*)norm_weight)[0].shape); + if ((((DLTensor*)gemm_out_mul)[0].ndim) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_1; + result_1.type_index = kTVMFFINone; + result_1.zero_padding = 0; + result_1.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_1) != 0) { + return -1; + } + } + if (!((bool)1)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "Symbolic shape variable num_tokens requires at least one non-null buffer among: mhc_pre_big_fuse_with_norm_tilelang.gemm_out_mul, mhc_pre_big_fuse_with_norm_tilelang.gemm_out_sqrsum, mhc_pre_big_fuse_with_norm_tilelang.residual, mhc_pre_big_fuse_with_norm_tilelang.post_mix, mhc_pre_big_fuse_with_norm_tilelang.comb_mix, mhc_pre_big_fuse_with_norm_tilelang.layer_input"); + return -1; + } + int32_t num_tokens = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]); + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides = (((DLTensor*)gemm_out_mul)[0].strides); + int32_t dev_id = (((DLTensor*)gemm_out_mul)[0].device.device_id); + void* gemm_out_mul_1 = (((DLTensor*)gemm_out_mul)[0].data); + if ((((DLTensor*)gemm_out_sqrsum)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_2; + result_2.type_index = kTVMFFINone; + result_2.zero_padding = 0; + result_2.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_2) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides = (((DLTensor*)gemm_out_sqrsum)[0].strides); + void* gemm_out_sqrsum_1 = (((DLTensor*)gemm_out_sqrsum)[0].data); + if ((((DLTensor*)hc_scale)[0].ndim) != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_3; + result_3.type_index = kTVMFFINone; + result_3.zero_padding = 0; + result_3.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_3) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides = (((DLTensor*)hc_scale)[0].strides); + void* hc_scale_1 = (((DLTensor*)hc_scale)[0].data); + if ((((DLTensor*)hc_base)[0].ndim) != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_4; + result_4.type_index = kTVMFFINone; + result_4.zero_padding = 0; + result_4.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_4) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides = (((DLTensor*)hc_base)[0].strides); + void* hc_base_1 = (((DLTensor*)hc_base)[0].data); + if ((((DLTensor*)residual)[0].ndim) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_5; + result_5.type_index = kTVMFFINone; + result_5.zero_padding = 0; + result_5.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_5) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_residual_strides = (((DLTensor*)residual)[0].strides); + void* residual_1 = (((DLTensor*)residual)[0].data); + if ((((DLTensor*)post_mix)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_6; + result_6.type_index = kTVMFFINone; + result_6.zero_padding = 0; + result_6.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_6) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides = (((DLTensor*)post_mix)[0].strides); + void* post_mix_1 = (((DLTensor*)post_mix)[0].data); + if ((((DLTensor*)comb_mix)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_7; + result_7.type_index = kTVMFFINone; + result_7.zero_padding = 0; + result_7.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_7) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides = (((DLTensor*)comb_mix)[0].strides); + void* comb_mix_1 = (((DLTensor*)comb_mix)[0].data); + if ((((DLTensor*)layer_input)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_8; + result_8.type_index = kTVMFFINone; + result_8.zero_padding = 0; + result_8.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_8) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides = (((DLTensor*)layer_input)[0].strides); + void* layer_input_1 = (((DLTensor*)layer_input)[0].data); + if ((((DLTensor*)norm_weight)[0].ndim) != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_9; + result_9.type_index = kTVMFFINone; + result_9.zero_padding = 0; + result_9.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_9) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides = (((DLTensor*)norm_weight)[0].strides); + void* norm_weight_1 = (((DLTensor*)norm_weight)[0].data); + if ((((((DLTensor*)gemm_out_mul)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)gemm_out_mul)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)gemm_out_mul)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_10; + result_10.type_index = kTVMFFINone; + result_10.zero_padding = 0; + result_10.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_10) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[0]) != 5) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)5; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_11; + result_11.type_index = kTVMFFINone; + result_11.zero_padding = 0; + result_11.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_11) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[2]) != 24) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)24; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[2])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_12; + result_12.type_index = kTVMFFINone; + result_12.zero_padding = 0; + result_12.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_12) != 0) { + return -1; + } + } + int32_t condval; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval = 1; + } else { + condval = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[2]); + } + if (condval != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_1; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval_1 = 1; + } else { + condval_1 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[2]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_1); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_13; + result_13.type_index = kTVMFFINone; + result_13.zero_padding = 0; + result_13.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_13) != 0) { + return -1; + } + } + int32_t condval_2; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval_2 = 1; + } else { + condval_2 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[1]); + } + if ((condval_2 != 24) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_14; + result_14.type_index = kTVMFFINone; + result_14.zero_padding = 0; + result_14.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_14) != 0) { + return -1; + } + } + int32_t condval_3; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval_3 = 1; + } else { + condval_3 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[0]); + } + if (((num_tokens * 24) != condval_3) && (num_tokens != 0)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_15; + result_15.type_index = kTVMFFINone; + result_15.zero_padding = 0; + result_15.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_15) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)gemm_out_mul)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_16; + result_16.type_index = kTVMFFINone; + result_16.zero_padding = 0; + result_16.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_16) != 0) { + return -1; + } + } + if ((((DLTensor*)gemm_out_mul)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_17; + result_17.type_index = kTVMFFINone; + result_17.zero_padding = 0; + result_17.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_17) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (gemm_out_mul_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_18; + result_18.type_index = kTVMFFINone; + result_18.zero_padding = 0; + result_18.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_18) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)gemm_out_sqrsum)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)gemm_out_sqrsum)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)gemm_out_sqrsum)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_19; + result_19.type_index = kTVMFFINone; + result_19.zero_padding = 0; + result_19.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_19) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[0]) != 5) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)5; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_20; + result_20.type_index = kTVMFFINone; + result_20.zero_padding = 0; + result_20.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_20) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[1])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_21; + result_21.type_index = kTVMFFINone; + result_21.zero_padding = 0; + result_21.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_21) != 0) { + return -1; + } + } + int32_t condval_4; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides == NULL)) { + condval_4 = 1; + } else { + condval_4 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides)[1]); + } + if ((condval_4 != 1) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_22; + result_22.type_index = kTVMFFINone; + result_22.zero_padding = 0; + result_22.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_22) != 0) { + return -1; + } + } + int32_t condval_5; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides == NULL)) { + condval_5 = 1; + } else { + condval_5 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides)[0]); + } + if ((((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != condval_5) && (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != 0)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_23; + result_23.type_index = kTVMFFINone; + result_23.zero_padding = 0; + result_23.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_23) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)gemm_out_sqrsum)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_24; + result_24.type_index = kTVMFFINone; + result_24.zero_padding = 0; + result_24.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_24) != 0) { + return -1; + } + } + if ((((DLTensor*)gemm_out_sqrsum)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_25; + result_25.type_index = kTVMFFINone; + result_25.zero_padding = 0; + result_25.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_25) != 0) { + return -1; + } + } + if ((((DLTensor*)gemm_out_sqrsum)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_26; + result_26.type_index = kTVMFFINone; + result_26.zero_padding = 0; + result_26.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_26) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (gemm_out_sqrsum_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_27; + result_27.type_index = kTVMFFINone; + result_27.zero_padding = 0; + result_27.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_27) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)hc_scale)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)hc_scale)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)hc_scale)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_28; + result_28.type_index = kTVMFFINone; + result_28.zero_padding = 0; + result_28.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_28) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_shape)[0]) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_29; + result_29.type_index = kTVMFFINone; + result_29.zero_padding = 0; + result_29.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_29) != 0) { + return -1; + } + } + int32_t condval_6; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides == NULL)) { + condval_6 = 1; + } else { + condval_6 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides)[0]); + } + if (condval_6 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_7; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides == NULL)) { + condval_7 = 1; + } else { + condval_7 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides)[0]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_7); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_30; + result_30.type_index = kTVMFFINone; + result_30.zero_padding = 0; + result_30.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_30) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)hc_scale)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_31; + result_31.type_index = kTVMFFINone; + result_31.zero_padding = 0; + result_31.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_31) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_scale)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_32; + result_32.type_index = kTVMFFINone; + result_32.zero_padding = 0; + result_32.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_32) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_scale)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_33; + result_33.type_index = kTVMFFINone; + result_33.zero_padding = 0; + result_33.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_33) != 0) { + return -1; + } + } + if (hc_scale_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_34; + result_34.type_index = kTVMFFINone; + result_34.zero_padding = 0; + result_34.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_34) != 0) { + return -1; + } + } + if ((((((DLTensor*)hc_base)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)hc_base)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)hc_base)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_35; + result_35.type_index = kTVMFFINone; + result_35.zero_padding = 0; + result_35.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_35) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_shape)[0]) != 24) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)24; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_36; + result_36.type_index = kTVMFFINone; + result_36.zero_padding = 0; + result_36.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_36) != 0) { + return -1; + } + } + int32_t condval_8; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides == NULL)) { + condval_8 = 1; + } else { + condval_8 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides)[0]); + } + if (condval_8 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_9; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides == NULL)) { + condval_9 = 1; + } else { + condval_9 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides)[0]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_9); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_37; + result_37.type_index = kTVMFFINone; + result_37.zero_padding = 0; + result_37.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_37) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)hc_base)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_38; + result_38.type_index = kTVMFFINone; + result_38.zero_padding = 0; + result_38.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_38) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_base)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_39; + result_39.type_index = kTVMFFINone; + result_39.zero_padding = 0; + result_39.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_39) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_base)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_40; + result_40.type_index = kTVMFFINone; + result_40.zero_padding = 0; + result_40.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_40) != 0) { + return -1; + } + } + if (hc_base_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_41; + result_41.type_index = kTVMFFINone; + result_41.zero_padding = 0; + result_41.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_41) != 0) { + return -1; + } + } + if ((((((DLTensor*)residual)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)residual)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)residual)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)residual)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)residual)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_42; + result_42.type_index = kTVMFFINone; + result_42.zero_padding = 0; + result_42.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_42) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_43; + result_43.type_index = kTVMFFINone; + result_43.zero_padding = 0; + result_43.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_43) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[1]) != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_44; + result_44.type_index = kTVMFFINone; + result_44.zero_padding = 0; + result_44.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_44) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[2]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[2])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_45; + result_45.type_index = kTVMFFINone; + result_45.zero_padding = 0; + result_45.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_45) != 0) { + return -1; + } + } + int32_t condval_10; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_10 = 1; + } else { + condval_10 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[2]); + } + if (condval_10 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_11; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_11 = 1; + } else { + condval_11 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[2]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_11); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_46; + result_46.type_index = kTVMFFINone; + result_46.zero_padding = 0; + result_46.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_46) != 0) { + return -1; + } + } + int32_t condval_12; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_12 = 1; + } else { + condval_12 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[1]); + } + if (condval_12 != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_13; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_13 = 1; + } else { + condval_13 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_13); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_47; + result_47.type_index = kTVMFFINone; + result_47.zero_padding = 0; + result_47.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_47) != 0) { + return -1; + } + } + int32_t condval_14; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_14 = 1; + } else { + condval_14 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[0]); + } + if ((condval_14 != 16384) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_48; + result_48.type_index = kTVMFFINone; + result_48.zero_padding = 0; + result_48.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_48) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)residual)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_49; + result_49.type_index = kTVMFFINone; + result_49.zero_padding = 0; + result_49.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_49) != 0) { + return -1; + } + } + if ((((DLTensor*)residual)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)residual)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_50; + result_50.type_index = kTVMFFINone; + result_50.zero_padding = 0; + result_50.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_50) != 0) { + return -1; + } + } + if ((((DLTensor*)residual)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_51; + result_51.type_index = kTVMFFINone; + result_51.zero_padding = 0; + result_51.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_51) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (residual_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_52; + result_52.type_index = kTVMFFINone; + result_52.zero_padding = 0; + result_52.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_52) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)post_mix)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)post_mix)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)post_mix)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_53; + result_53.type_index = kTVMFFINone; + result_53.zero_padding = 0; + result_53.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_53) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_54; + result_54.type_index = kTVMFFINone; + result_54.zero_padding = 0; + result_54.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_54) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[1]) != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_55; + result_55.type_index = kTVMFFINone; + result_55.zero_padding = 0; + result_55.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_55) != 0) { + return -1; + } + } + int32_t condval_15; + if ((mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides == NULL)) { + condval_15 = 1; + } else { + condval_15 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides)[1]); + } + if (condval_15 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_16; + if ((mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides == NULL)) { + condval_16 = 1; + } else { + condval_16 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_16); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_56; + result_56.type_index = kTVMFFINone; + result_56.zero_padding = 0; + result_56.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_56) != 0) { + return -1; + } + } + int32_t condval_17; + if ((mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides == NULL)) { + condval_17 = 1; + } else { + condval_17 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides)[0]); + } + if ((condval_17 != 4) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_57; + result_57.type_index = kTVMFFINone; + result_57.zero_padding = 0; + result_57.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_57) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)post_mix)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_58; + result_58.type_index = kTVMFFINone; + result_58.zero_padding = 0; + result_58.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_58) != 0) { + return -1; + } + } + if ((((DLTensor*)post_mix)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_59; + result_59.type_index = kTVMFFINone; + result_59.zero_padding = 0; + result_59.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_59) != 0) { + return -1; + } + } + if ((((DLTensor*)post_mix)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_60; + result_60.type_index = kTVMFFINone; + result_60.zero_padding = 0; + result_60.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_60) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (post_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_61; + result_61.type_index = kTVMFFINone; + result_61.zero_padding = 0; + result_61.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_61) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)comb_mix)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)comb_mix)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)comb_mix)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_62; + result_62.type_index = kTVMFFINone; + result_62.zero_padding = 0; + result_62.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_62) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_63; + result_63.type_index = kTVMFFINone; + result_63.zero_padding = 0; + result_63.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_63) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[1]) != 16) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_64; + result_64.type_index = kTVMFFINone; + result_64.zero_padding = 0; + result_64.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_64) != 0) { + return -1; + } + } + int32_t condval_18; + if ((mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides == NULL)) { + condval_18 = 1; + } else { + condval_18 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides)[1]); + } + if (condval_18 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_19; + if ((mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides == NULL)) { + condval_19 = 1; + } else { + condval_19 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_19); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_65; + result_65.type_index = kTVMFFINone; + result_65.zero_padding = 0; + result_65.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_65) != 0) { + return -1; + } + } + int32_t condval_20; + if ((mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides == NULL)) { + condval_20 = 1; + } else { + condval_20 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides)[0]); + } + if ((condval_20 != 16) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_66; + result_66.type_index = kTVMFFINone; + result_66.zero_padding = 0; + result_66.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_66) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)comb_mix)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_67; + result_67.type_index = kTVMFFINone; + result_67.zero_padding = 0; + result_67.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_67) != 0) { + return -1; + } + } + if ((((DLTensor*)comb_mix)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_68; + result_68.type_index = kTVMFFINone; + result_68.zero_padding = 0; + result_68.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_68) != 0) { + return -1; + } + } + if ((((DLTensor*)comb_mix)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_69; + result_69.type_index = kTVMFFINone; + result_69.zero_padding = 0; + result_69.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_69) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (comb_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_70; + result_70.type_index = kTVMFFINone; + result_70.zero_padding = 0; + result_70.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_70) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)layer_input)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)layer_input)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)layer_input)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_71; + result_71.type_index = kTVMFFINone; + result_71.zero_padding = 0; + result_71.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_71) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_72; + result_72.type_index = kTVMFFINone; + result_72.zero_padding = 0; + result_72.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_72) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[1]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_73; + result_73.type_index = kTVMFFINone; + result_73.zero_padding = 0; + result_73.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_73) != 0) { + return -1; + } + } + int32_t condval_21; + if ((mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides == NULL)) { + condval_21 = 1; + } else { + condval_21 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides)[1]); + } + if (condval_21 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_22; + if ((mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides == NULL)) { + condval_22 = 1; + } else { + condval_22 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_22); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_74; + result_74.type_index = kTVMFFINone; + result_74.zero_padding = 0; + result_74.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_74) != 0) { + return -1; + } + } + int32_t condval_23; + if ((mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides == NULL)) { + condval_23 = 1; + } else { + condval_23 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides)[0]); + } + if ((condval_23 != 4096) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_75; + result_75.type_index = kTVMFFINone; + result_75.zero_padding = 0; + result_75.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_75) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)layer_input)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_76; + result_76.type_index = kTVMFFINone; + result_76.zero_padding = 0; + result_76.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_76) != 0) { + return -1; + } + } + if ((((DLTensor*)layer_input)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_77; + result_77.type_index = kTVMFFINone; + result_77.zero_padding = 0; + result_77.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_77) != 0) { + return -1; + } + } + if ((((DLTensor*)layer_input)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_78; + result_78.type_index = kTVMFFINone; + result_78.zero_padding = 0; + result_78.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_78) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (layer_input_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_79; + result_79.type_index = kTVMFFINone; + result_79.zero_padding = 0; + result_79.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_79) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)norm_weight)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)norm_weight)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)norm_weight)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_80; + result_80.type_index = kTVMFFINone; + result_80.zero_padding = 0; + result_80.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_80) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_shape)[0]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_81; + result_81.type_index = kTVMFFINone; + result_81.zero_padding = 0; + result_81.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_81) != 0) { + return -1; + } + } + int32_t condval_24; + if ((mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides == NULL)) { + condval_24 = 1; + } else { + condval_24 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides)[0]); + } + if (condval_24 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_25; + if ((mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides == NULL)) { + condval_25 = 1; + } else { + condval_25 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides)[0]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_25); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_82; + result_82.type_index = kTVMFFINone; + result_82.zero_padding = 0; + result_82.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_82) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)norm_weight)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_83; + result_83.type_index = kTVMFFINone; + result_83.zero_padding = 0; + result_83.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_83) != 0) { + return -1; + } + } + if ((((DLTensor*)norm_weight)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_84; + result_84.type_index = kTVMFFINone; + result_84.zero_padding = 0; + result_84.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_84) != 0) { + return -1; + } + } + if ((((DLTensor*)norm_weight)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_85; + result_85.type_index = kTVMFFINone; + result_85.zero_padding = 0; + result_85.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_85) != 0) { + return -1; + } + } + if (norm_weight_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_86; + result_86.type_index = kTVMFFINone; + result_86.zero_padding = 0; + result_86.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_86) != 0) { + return -1; + } + } + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = ((int64_t)2); + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = ((int64_t)dev_id); + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + if (__tvm_set_device_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_set_device", &__tvm_set_device_packed) != 0) { + return -1; + } + } + TVMFFIAny result_87; + result_87.type_index = kTVMFFINone; + result_87.zero_padding = 0; + result_87.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_set_device_packed, (TVMFFIAny*) stack_ffi_any, 2, &result_87) != 0) { + return -1; + } + if (comb_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = comb_mix_1; + if (gemm_out_mul_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = gemm_out_mul_1; + if (gemm_out_sqrsum_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = gemm_out_sqrsum_1; + if (hc_base_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_ptr) = hc_base_1; + if (hc_scale_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_ptr) = hc_scale_1; + if (layer_input_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_ptr) = layer_input_1; + if (norm_weight_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_ptr) = norm_weight_1; + if (post_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_ptr) = post_mix_1; + if (residual_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_ptr) = residual_1; + (((TVMFFIAny*)stack_ffi_any)[9].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[9].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[9].v_int64) = ((int64_t)num_tokens); + (((TVMFFIAny*)stack_ffi_any)[10].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[10].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[10].v_int64) = ((int64_t)num_tokens); + (((TVMFFIAny*)stack_ffi_any)[11].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[11].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[11].v_int64) = ((int64_t)96); + (((TVMFFIAny*)stack_ffi_any)[12].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[12].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[12].v_int64) = ((int64_t)1); + (((TVMFFIAny*)stack_ffi_any)[13].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[13].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[13].v_int64) = ((int64_t)1); + (((TVMFFIAny*)stack_ffi_any)[14].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[14].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[14].v_int64) = ((int64_t)29040); + (((TVMFFIAny*)stack_ffi_any)[15].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[15].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[15].v_int64) = (int64_t)0; + if (mhc_pre_big_fuse_with_norm_tilelang_kernel_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "mhc_pre_big_fuse_with_norm_tilelang_kernel", &mhc_pre_big_fuse_with_norm_tilelang_kernel_packed) != 0) { + return -1; + } + } + TVMFFIAny result_88; + result_88.type_index = kTVMFFINone; + result_88.zero_padding = 0; + result_88.v_int64 = 0; + if (TVMFFIFunctionCall(mhc_pre_big_fuse_with_norm_tilelang_kernel_packed, (TVMFFIAny*) stack_ffi_any, 15, &result_88) != 0) { + return -1; + } + return 0; +} + +// CodegenC: NOTE: Auto-generated entry function +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_main(void* self, void* args,int num_args, void* result) { + return __tvm_ffi_mhc_pre_big_fuse_with_norm_tilelang(self, args, num_args, result); +} diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/8ac26e5a6bf2572ea507280b0cfe38c49999af7cb683ccecde6888c37a6e6f3a/params.pkl b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/8ac26e5a6bf2572ea507280b0cfe38c49999af7cb683ccecde6888c37a6e6f3a/params.pkl new file mode 100644 index 0000000..cef5ff9 Binary files /dev/null and b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/8ac26e5a6bf2572ea507280b0cfe38c49999af7cb683ccecde6888c37a6e6f3a/params.pkl differ diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/94b96c76ed4b18c5a1404f5c71d4cc9c8be8d3d582285c754714502150b21353/device_kernel.cu b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/94b96c76ed4b18c5a1404f5c71d4cc9c8be8d3d582285c754714502150b21353/device_kernel.cu new file mode 100644 index 0000000..7c69186 --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/94b96c76ed4b18c5a1404f5c71d4cc9c8be8d3d582285c754714502150b21353/device_kernel.cu @@ -0,0 +1,104 @@ +#include +#include +#include +#include +#include +#include +#ifdef ENABLE_BF16 +#include +#endif + +extern "C" __global__ void mhc_fused_tilelang_kernel(const float* comb_mix, const float* post_mix, const bfloat16_t* residual_in, bfloat16_t* residual_out, float* rp_out, const float* weight_t, const bfloat16_t* x_in, float* yp_out, int num_tokens, int split_k); +extern "C" __global__ void __launch_bounds__(256, 1) mhc_fused_tilelang_kernel(const float* comb_mix, const float* post_mix, const bfloat16_t* residual_in, bfloat16_t* residual_out, float* rp_out, const float* weight_t, const bfloat16_t* x_in, float* yp_out, int num_tokens, int split_k) { + extern __shared__ __align__(1024) uchar buf_dyn_shmem[]; + float acc[3]; + float sqr[1]; + float pm[4]; + float cm[16]; + float new_r[4]; + float v = 0x0p+0f/*0.000000e+00*/; + float v2 = 0x0p+0f/*0.000000e+00*/; + #pragma unroll + for (int i = 0; i < 3; ++i) { + acc[i] = 0x0p+0f/*0.000000e+00*/; + } + sqr[0] = 0x0p+0f/*0.000000e+00*/; + cudaGridDependencySynchronize(); + if (((int)threadIdx.x) < 4) { + ((float*)buf_dyn_shmem)[((int)threadIdx.x)] = post_mix[((((int64_t)((int)blockIdx.x)) * (int64_t)4) + ((int64_t)((int)threadIdx.x)))]; + } + if (((int)threadIdx.x) < 16) { + ((float*)buf_dyn_shmem)[(((int)threadIdx.x) + 4)] = comb_mix[((((int64_t)((int)blockIdx.x)) * (int64_t)16) + ((int64_t)((int)threadIdx.x)))]; + } + __syncthreads(); + #pragma unroll + for (int j = 0; j < 4; ++j) { + pm[j] = ((float*)buf_dyn_shmem)[j]; + } + #pragma unroll + for (int j_1 = 0; j_1 < 4; ++j_1) { + #pragma unroll + for (int k = 0; k < 4; ++k) { + cm[((k * 4) + j_1)] = ((float*)buf_dyn_shmem)[(((k * 4) + j_1) + 4)]; + } + } + for (int it = 0; it < ((4096 / split_k) >> 8); ++it) { + #pragma unroll + for (int j_2 = 0; j_2 < 4; ++j_2) { + new_r[j_2] = (pm[j_2] * ((float)x_in[((((((int64_t)((int)blockIdx.x)) * (int64_t)4096) + (((int64_t)it) * (int64_t)256)) + (((int64_t)((int)blockIdx.z)) * ((int64_t)4096 / ((int64_t)split_k)))) + ((int64_t)((int)threadIdx.x)))])); + #pragma unroll + for (int k_1 = 0; k_1 < 4; ++k_1) { + new_r[j_2] = (new_r[j_2] + (cm[((k_1 * 4) + j_2)] * ((float)residual_in[(((((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + (((int64_t)k_1) * (int64_t)4096)) + (((int64_t)it) * (int64_t)256)) + (((int64_t)((int)blockIdx.z)) * ((int64_t)4096 / ((int64_t)split_k)))) + ((int64_t)((int)threadIdx.x)))]))); + } + } + if (((int)blockIdx.y) == 0) { + #pragma unroll + for (int j_3 = 0; j_3 < 4; ++j_3) { + residual_out[(((((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + (((int64_t)j_3) * (int64_t)4096)) + (((int64_t)it) * (int64_t)256)) + (((int64_t)((int)blockIdx.z)) * ((int64_t)4096 / ((int64_t)split_k)))) + ((int64_t)((int)threadIdx.x)))] = ((bfloat16_t)new_r[j_3]); + sqr[0] = (sqr[0] + (new_r[j_3] * new_r[j_3])); + } + } + #pragma unroll + for (int n = 0; n < 3; ++n) { + #pragma unroll + for (int j_4 = 0; j_4 < 4; ++j_4) { + acc[n] = (acc[n] + (weight_t[((((((((int64_t)((int)blockIdx.y)) * (int64_t)49152) + (((int64_t)n) * (int64_t)16384)) + (((int64_t)j_4) * (int64_t)4096)) + (((int64_t)it) * (int64_t)256)) + (((int64_t)((int)blockIdx.z)) * ((int64_t)4096 / ((int64_t)split_k)))) + ((int64_t)((int)threadIdx.x)))] * new_r[j_4])); + } + } + } + #pragma unroll + for (int n_1 = 0; n_1 < 3; ++n_1) { + acc[n_1] = tl::warp_reduce_sum(acc[n_1]); + } + if (((int)blockIdx.y) == 0) { + sqr[0] = tl::warp_reduce_sum(sqr[0]); + } + if ((((int)threadIdx.x) % 32) == 0) { + #pragma unroll + for (int n_2 = 0; n_2 < 3; ++n_2) { + ((float*)buf_dyn_shmem)[((((((int)threadIdx.x) >> 5) * 4) + n_2) + 20)] = acc[n_2]; + } + if (((int)blockIdx.y) == 0) { + ((float*)buf_dyn_shmem)[(((((int)threadIdx.x) >> 5) * 4) + 23)] = sqr[0]; + } + } + __syncthreads(); + if ((((int)threadIdx.x) >> 5) == 0) { + if ((((int)threadIdx.x) & 31) < 3) { + #pragma unroll + for (int w = 0; w < 8; ++w) { + v = (v + ((float*)buf_dyn_shmem)[(((w * 4) + (((int)threadIdx.x) & 31)) + 20)]); + } + yp_out[((((((int64_t)((int)blockIdx.x)) * (int64_t)24) + ((((int64_t)((int)blockIdx.z)) * ((int64_t)num_tokens)) * (int64_t)24)) + (((int64_t)((int)blockIdx.y)) * (int64_t)3)) + (((int64_t)((int)threadIdx.x)) & (int64_t)31))] = v; + } + if ((((int)blockIdx.y) == 0) && ((((int)threadIdx.x) % 32) == 0)) { + #pragma unroll + for (int w_1 = 0; w_1 < 8; ++w_1) { + v2 = (v2 + ((float*)buf_dyn_shmem)[((w_1 * 4) + 23)]); + } + rp_out[((((int64_t)((int)blockIdx.z)) * ((int64_t)num_tokens)) + ((int64_t)((int)blockIdx.x)))] = v2; + } + } + cudaTriggerProgrammaticLaunchCompletion(); +} + diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/94b96c76ed4b18c5a1404f5c71d4cc9c8be8d3d582285c754714502150b21353/host_kernel.cu b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/94b96c76ed4b18c5a1404f5c71d4cc9c8be8d3d582285c754714502150b21353/host_kernel.cu new file mode 100644 index 0000000..8167a97 --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/94b96c76ed4b18c5a1404f5c71d4cc9c8be8d3d582285c754714502150b21353/host_kernel.cu @@ -0,0 +1,3435 @@ +// tilelang target: c -keys=cpu +#define TVM_EXPORTS +#include "tvm/runtime/base.h" +#include "tvm/runtime/c_backend_api.h" +#include "tvm/ffi/c_api.h" +#include +#include +#include +#ifdef __OBJC__ +#include "tvm/runtime/device_api.h" +#include "tvm/ffi/function.h" +#include +#include +#include +#endif +void* __tvm_ffi__library_ctx = NULL; +static void* __tvm_error_ndim_mismatch_packed = NULL; +static void* __tvm_error_dtype_mismatch_packed = NULL; +static void* __tvm_error_expect_eq_packed = NULL; +static void* __tvm_error_constraint_violation_packed = NULL; +static void* __tvm_error_byte_offset_mismatch_packed = NULL; +static void* __tvm_error_device_type_mismatch_packed = NULL; +static void* __tvm_error_null_ptr_packed = NULL; +static void* __tvm_set_device_packed = NULL; +static void* mhc_fused_tilelang_kernel_packed = NULL; +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_mhc_fused_tilelang(void* self_handle, void* args, int32_t num_args, void* result); +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_mhc_fused_tilelang(void* self_handle, void* args, int32_t num_args, void* result) { + __attribute__((aligned(64))) TVMFFIAny stack[18]; + void* stack_ffi_any = stack; + if (!((num_args == 8))) { + char __tvm_assert_msg_buf[512]; + snprintf(__tvm_assert_msg_buf, 512, "%s; expected: %lld, got: %lld", "mhc_fused_tilelang: num_args should be 8", (long long)(num_args), (long long)(8)); + TVMFFIErrorSetRaisedFromCStr("RuntimeError", __tvm_assert_msg_buf); + return -1; + } + if (!(!(args == NULL))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_fused_tilelang: args pointer is NULL"); + return -1; + } + int32_t comb_mix_type_index = (((TVMFFIAny*)args)[0].type_index); + if (!(((((comb_mix_type_index == 0) || (comb_mix_type_index == 4)) || (comb_mix_type_index == 7)) || (64 <= comb_mix_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_fused_tilelang input comb_mix expected pointer or tensor handle"); + return -1; + } + int32_t residual_in_type_index = (((TVMFFIAny*)args)[1].type_index); + if (!(((((residual_in_type_index == 0) || (residual_in_type_index == 4)) || (residual_in_type_index == 7)) || (64 <= residual_in_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_fused_tilelang input residual_in expected pointer or tensor handle"); + return -1; + } + int32_t post_mix_type_index = (((TVMFFIAny*)args)[2].type_index); + if (!(((((post_mix_type_index == 0) || (post_mix_type_index == 4)) || (post_mix_type_index == 7)) || (64 <= post_mix_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_fused_tilelang input post_mix expected pointer or tensor handle"); + return -1; + } + int32_t x_in_type_index = (((TVMFFIAny*)args)[3].type_index); + if (!(((((x_in_type_index == 0) || (x_in_type_index == 4)) || (x_in_type_index == 7)) || (64 <= x_in_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_fused_tilelang input x_in expected pointer or tensor handle"); + return -1; + } + int32_t weight_t_type_index = (((TVMFFIAny*)args)[4].type_index); + if (!(((((weight_t_type_index == 0) || (weight_t_type_index == 4)) || (weight_t_type_index == 7)) || (64 <= weight_t_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_fused_tilelang input weight_t expected pointer or tensor handle"); + return -1; + } + int32_t yp_out_type_index = (((TVMFFIAny*)args)[5].type_index); + if (!(((((yp_out_type_index == 0) || (yp_out_type_index == 4)) || (yp_out_type_index == 7)) || (64 <= yp_out_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_fused_tilelang input yp_out expected pointer or tensor handle"); + return -1; + } + int32_t rp_out_type_index = (((TVMFFIAny*)args)[6].type_index); + if (!(((((rp_out_type_index == 0) || (rp_out_type_index == 4)) || (rp_out_type_index == 7)) || (64 <= rp_out_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_fused_tilelang input rp_out expected pointer or tensor handle"); + return -1; + } + int32_t residual_out_type_index = (((TVMFFIAny*)args)[7].type_index); + if (!(((((residual_out_type_index == 0) || (residual_out_type_index == 4)) || (residual_out_type_index == 7)) || (64 <= residual_out_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_fused_tilelang input residual_out expected pointer or tensor handle"); + return -1; + } + void* comb_mix = ((comb_mix_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[0].v_ptr) + 24)) : (((TVMFFIAny*)args)[0].v_ptr)); + void* residual_in = ((residual_in_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[1].v_ptr) + 24)) : (((TVMFFIAny*)args)[1].v_ptr)); + void* post_mix = ((post_mix_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[2].v_ptr) + 24)) : (((TVMFFIAny*)args)[2].v_ptr)); + void* x_in = ((x_in_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[3].v_ptr) + 24)) : (((TVMFFIAny*)args)[3].v_ptr)); + void* weight_t = ((weight_t_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[4].v_ptr) + 24)) : (((TVMFFIAny*)args)[4].v_ptr)); + void* yp_out = ((yp_out_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[5].v_ptr) + 24)) : (((TVMFFIAny*)args)[5].v_ptr)); + void* rp_out = ((rp_out_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[6].v_ptr) + 24)) : (((TVMFFIAny*)args)[6].v_ptr)); + void* residual_out = ((residual_out_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[7].v_ptr) + 24)) : (((TVMFFIAny*)args)[7].v_ptr)); + bool mhc_fused_tilelang_comb_mix_is_null = (comb_mix == NULL); + if (!(!mhc_fused_tilelang_comb_mix_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_fused_tilelang.comb_mix is expected to have non-NULL pointer"); + return -1; + } + bool mhc_fused_tilelang_residual_in_is_null = (residual_in == NULL); + if (!(!mhc_fused_tilelang_residual_in_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_fused_tilelang.residual_in is expected to have non-NULL pointer"); + return -1; + } + bool mhc_fused_tilelang_post_mix_is_null = (post_mix == NULL); + if (!(!mhc_fused_tilelang_post_mix_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_fused_tilelang.post_mix is expected to have non-NULL pointer"); + return -1; + } + bool mhc_fused_tilelang_x_in_is_null = (x_in == NULL); + if (!(!mhc_fused_tilelang_x_in_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_fused_tilelang.x_in is expected to have non-NULL pointer"); + return -1; + } + bool mhc_fused_tilelang_weight_t_is_null = (weight_t == NULL); + if (!(!mhc_fused_tilelang_weight_t_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_fused_tilelang.weight_t is expected to have non-NULL pointer"); + return -1; + } + bool mhc_fused_tilelang_yp_out_is_null = (yp_out == NULL); + if (!(!mhc_fused_tilelang_yp_out_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_fused_tilelang.yp_out is expected to have non-NULL pointer"); + return -1; + } + bool mhc_fused_tilelang_rp_out_is_null = (rp_out == NULL); + if (!(!mhc_fused_tilelang_rp_out_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_fused_tilelang.rp_out is expected to have non-NULL pointer"); + return -1; + } + bool mhc_fused_tilelang_residual_out_is_null = (residual_out == NULL); + if (!(!mhc_fused_tilelang_residual_out_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_fused_tilelang.residual_out is expected to have non-NULL pointer"); + return -1; + } + void* mhc_fused_tilelang_comb_mix_shape = (((DLTensor*)comb_mix)[0].shape); + void* mhc_fused_tilelang_residual_in_shape = (((DLTensor*)residual_in)[0].shape); + void* mhc_fused_tilelang_post_mix_shape = (((DLTensor*)post_mix)[0].shape); + void* mhc_fused_tilelang_x_in_shape = (((DLTensor*)x_in)[0].shape); + void* mhc_fused_tilelang_weight_t_shape = (((DLTensor*)weight_t)[0].shape); + void* mhc_fused_tilelang_yp_out_shape = (((DLTensor*)yp_out)[0].shape); + void* mhc_fused_tilelang_rp_out_shape = (((DLTensor*)rp_out)[0].shape); + void* mhc_fused_tilelang_residual_out_shape = (((DLTensor*)residual_out)[0].shape); + if ((((DLTensor*)comb_mix)[0].ndim) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_1; + result_1.type_index = kTVMFFINone; + result_1.zero_padding = 0; + result_1.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_1) != 0) { + return -1; + } + } + if (!((bool)1)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "Symbolic shape variable num_tokens requires at least one non-null buffer among: mhc_fused_tilelang.comb_mix, mhc_fused_tilelang.residual_in, mhc_fused_tilelang.post_mix, mhc_fused_tilelang.x_in, mhc_fused_tilelang.yp_out, mhc_fused_tilelang.rp_out, mhc_fused_tilelang.residual_out"); + return -1; + } + int32_t num_tokens = ((int32_t)((int64_t*)mhc_fused_tilelang_comb_mix_shape)[0]); + void* mhc_fused_tilelang_comb_mix_strides = (((DLTensor*)comb_mix)[0].strides); + int32_t dev_id = (((DLTensor*)comb_mix)[0].device.device_id); + void* comb_mix_1 = (((DLTensor*)comb_mix)[0].data); + if ((((DLTensor*)residual_in)[0].ndim) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual_in"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual_in)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_2; + result_2.type_index = kTVMFFINone; + result_2.zero_padding = 0; + result_2.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_2) != 0) { + return -1; + } + } + void* mhc_fused_tilelang_residual_in_strides = (((DLTensor*)residual_in)[0].strides); + void* residual_in_1 = (((DLTensor*)residual_in)[0].data); + if ((((DLTensor*)post_mix)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_3; + result_3.type_index = kTVMFFINone; + result_3.zero_padding = 0; + result_3.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_3) != 0) { + return -1; + } + } + void* mhc_fused_tilelang_post_mix_strides = (((DLTensor*)post_mix)[0].strides); + void* post_mix_1 = (((DLTensor*)post_mix)[0].data); + if ((((DLTensor*)x_in)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"x_in"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)x_in)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_4; + result_4.type_index = kTVMFFINone; + result_4.zero_padding = 0; + result_4.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_4) != 0) { + return -1; + } + } + void* mhc_fused_tilelang_x_in_strides = (((DLTensor*)x_in)[0].strides); + void* x_in_1 = (((DLTensor*)x_in)[0].data); + if ((((DLTensor*)weight_t)[0].ndim) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"weight_t"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)weight_t)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_5; + result_5.type_index = kTVMFFINone; + result_5.zero_padding = 0; + result_5.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_5) != 0) { + return -1; + } + } + void* mhc_fused_tilelang_weight_t_strides = (((DLTensor*)weight_t)[0].strides); + void* weight_t_1 = (((DLTensor*)weight_t)[0].data); + if ((((DLTensor*)yp_out)[0].ndim) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"yp_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)yp_out)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_6; + result_6.type_index = kTVMFFINone; + result_6.zero_padding = 0; + result_6.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_6) != 0) { + return -1; + } + } + if (!((bool)1)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "Symbolic shape variable split_k requires at least one non-null buffer among: mhc_fused_tilelang.yp_out, mhc_fused_tilelang.rp_out"); + return -1; + } + int32_t split_k = ((int32_t)((int64_t*)mhc_fused_tilelang_yp_out_shape)[0]); + void* mhc_fused_tilelang_yp_out_strides = (((DLTensor*)yp_out)[0].strides); + void* yp_out_1 = (((DLTensor*)yp_out)[0].data); + if ((((DLTensor*)rp_out)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"rp_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)rp_out)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_7; + result_7.type_index = kTVMFFINone; + result_7.zero_padding = 0; + result_7.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_7) != 0) { + return -1; + } + } + void* mhc_fused_tilelang_rp_out_strides = (((DLTensor*)rp_out)[0].strides); + void* rp_out_1 = (((DLTensor*)rp_out)[0].data); + if ((((DLTensor*)residual_out)[0].ndim) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual_out)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_8; + result_8.type_index = kTVMFFINone; + result_8.zero_padding = 0; + result_8.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_8) != 0) { + return -1; + } + } + void* mhc_fused_tilelang_residual_out_strides = (((DLTensor*)residual_out)[0].strides); + void* residual_out_1 = (((DLTensor*)residual_out)[0].data); + if ((((((DLTensor*)comb_mix)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)comb_mix)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)comb_mix)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_9; + result_9.type_index = kTVMFFINone; + result_9.zero_padding = 0; + result_9.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_9) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_fused_tilelang_comb_mix_shape)[1]) != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_fused_tilelang_comb_mix_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_10; + result_10.type_index = kTVMFFINone; + result_10.zero_padding = 0; + result_10.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_10) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_fused_tilelang_comb_mix_shape)[2]) != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_fused_tilelang_comb_mix_shape)[2])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_11; + result_11.type_index = kTVMFFINone; + result_11.zero_padding = 0; + result_11.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_11) != 0) { + return -1; + } + } + int32_t condval; + if ((mhc_fused_tilelang_comb_mix_strides == NULL)) { + condval = 1; + } else { + condval = ((int32_t)((int64_t*)mhc_fused_tilelang_comb_mix_strides)[2]); + } + if (condval != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_1; + if ((mhc_fused_tilelang_comb_mix_strides == NULL)) { + condval_1 = 1; + } else { + condval_1 = ((int32_t)((int64_t*)mhc_fused_tilelang_comb_mix_strides)[2]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_1); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_12; + result_12.type_index = kTVMFFINone; + result_12.zero_padding = 0; + result_12.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_12) != 0) { + return -1; + } + } + int32_t condval_2; + if ((mhc_fused_tilelang_comb_mix_strides == NULL)) { + condval_2 = 1; + } else { + condval_2 = ((int32_t)((int64_t*)mhc_fused_tilelang_comb_mix_strides)[1]); + } + if (condval_2 != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_3; + if ((mhc_fused_tilelang_comb_mix_strides == NULL)) { + condval_3 = 1; + } else { + condval_3 = ((int32_t)((int64_t*)mhc_fused_tilelang_comb_mix_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_3); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_13; + result_13.type_index = kTVMFFINone; + result_13.zero_padding = 0; + result_13.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_13) != 0) { + return -1; + } + } + int32_t condval_4; + if ((mhc_fused_tilelang_comb_mix_strides == NULL)) { + condval_4 = 1; + } else { + condval_4 = ((int32_t)((int64_t*)mhc_fused_tilelang_comb_mix_strides)[0]); + } + if ((condval_4 != 16) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_14; + result_14.type_index = kTVMFFINone; + result_14.zero_padding = 0; + result_14.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_14) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)comb_mix)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_15; + result_15.type_index = kTVMFFINone; + result_15.zero_padding = 0; + result_15.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_15) != 0) { + return -1; + } + } + if ((((DLTensor*)comb_mix)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_16; + result_16.type_index = kTVMFFINone; + result_16.zero_padding = 0; + result_16.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_16) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (comb_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_17; + result_17.type_index = kTVMFFINone; + result_17.zero_padding = 0; + result_17.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_17) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)residual_in)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)residual_in)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)residual_in)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual_in"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)residual_in)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual_in)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)residual_in)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_18; + result_18.type_index = kTVMFFINone; + result_18.zero_padding = 0; + result_18.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_18) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_fused_tilelang_comb_mix_shape)[0]) != ((int32_t)((int64_t*)mhc_fused_tilelang_residual_in_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual_in"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_fused_tilelang_residual_in_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_fused_tilelang_comb_mix_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_19; + result_19.type_index = kTVMFFINone; + result_19.zero_padding = 0; + result_19.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_19) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_fused_tilelang_residual_in_shape)[1]) != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual_in"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_fused_tilelang_residual_in_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_20; + result_20.type_index = kTVMFFINone; + result_20.zero_padding = 0; + result_20.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_20) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_fused_tilelang_residual_in_shape)[2]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual_in"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_fused_tilelang_residual_in_shape)[2])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_21; + result_21.type_index = kTVMFFINone; + result_21.zero_padding = 0; + result_21.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_21) != 0) { + return -1; + } + } + int32_t condval_5; + if ((mhc_fused_tilelang_residual_in_strides == NULL)) { + condval_5 = 1; + } else { + condval_5 = ((int32_t)((int64_t*)mhc_fused_tilelang_residual_in_strides)[2]); + } + if (condval_5 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual_in"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_6; + if ((mhc_fused_tilelang_residual_in_strides == NULL)) { + condval_6 = 1; + } else { + condval_6 = ((int32_t)((int64_t*)mhc_fused_tilelang_residual_in_strides)[2]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_6); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_22; + result_22.type_index = kTVMFFINone; + result_22.zero_padding = 0; + result_22.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_22) != 0) { + return -1; + } + } + int32_t condval_7; + if ((mhc_fused_tilelang_residual_in_strides == NULL)) { + condval_7 = 1; + } else { + condval_7 = ((int32_t)((int64_t*)mhc_fused_tilelang_residual_in_strides)[1]); + } + if (condval_7 != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual_in"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_8; + if ((mhc_fused_tilelang_residual_in_strides == NULL)) { + condval_8 = 1; + } else { + condval_8 = ((int32_t)((int64_t*)mhc_fused_tilelang_residual_in_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_8); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_23; + result_23.type_index = kTVMFFINone; + result_23.zero_padding = 0; + result_23.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_23) != 0) { + return -1; + } + } + int32_t condval_9; + if ((mhc_fused_tilelang_residual_in_strides == NULL)) { + condval_9 = 1; + } else { + condval_9 = ((int32_t)((int64_t*)mhc_fused_tilelang_residual_in_strides)[0]); + } + if ((condval_9 != 16384) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual_in"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_24; + result_24.type_index = kTVMFFINone; + result_24.zero_padding = 0; + result_24.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_24) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)residual_in)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual_in"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual_in)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_25; + result_25.type_index = kTVMFFINone; + result_25.zero_padding = 0; + result_25.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_25) != 0) { + return -1; + } + } + if ((((DLTensor*)residual_in)[0].device.device_id) != (((DLTensor*)comb_mix)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual_in"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)residual_in)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_26; + result_26.type_index = kTVMFFINone; + result_26.zero_padding = 0; + result_26.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_26) != 0) { + return -1; + } + } + if ((((DLTensor*)residual_in)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual_in"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual_in)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_27; + result_27.type_index = kTVMFFINone; + result_27.zero_padding = 0; + result_27.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_27) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (residual_in_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual_in"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_28; + result_28.type_index = kTVMFFINone; + result_28.zero_padding = 0; + result_28.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_28) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)post_mix)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)post_mix)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)post_mix)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_29; + result_29.type_index = kTVMFFINone; + result_29.zero_padding = 0; + result_29.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_29) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_fused_tilelang_comb_mix_shape)[0]) != ((int32_t)((int64_t*)mhc_fused_tilelang_post_mix_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_fused_tilelang_post_mix_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_fused_tilelang_comb_mix_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_30; + result_30.type_index = kTVMFFINone; + result_30.zero_padding = 0; + result_30.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_30) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_fused_tilelang_post_mix_shape)[1]) != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_fused_tilelang_post_mix_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_31; + result_31.type_index = kTVMFFINone; + result_31.zero_padding = 0; + result_31.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_31) != 0) { + return -1; + } + } + int32_t condval_10; + if ((mhc_fused_tilelang_post_mix_strides == NULL)) { + condval_10 = 1; + } else { + condval_10 = ((int32_t)((int64_t*)mhc_fused_tilelang_post_mix_strides)[1]); + } + if (condval_10 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_11; + if ((mhc_fused_tilelang_post_mix_strides == NULL)) { + condval_11 = 1; + } else { + condval_11 = ((int32_t)((int64_t*)mhc_fused_tilelang_post_mix_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_11); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_32; + result_32.type_index = kTVMFFINone; + result_32.zero_padding = 0; + result_32.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_32) != 0) { + return -1; + } + } + int32_t condval_12; + if ((mhc_fused_tilelang_post_mix_strides == NULL)) { + condval_12 = 1; + } else { + condval_12 = ((int32_t)((int64_t*)mhc_fused_tilelang_post_mix_strides)[0]); + } + if ((condval_12 != 4) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_33; + result_33.type_index = kTVMFFINone; + result_33.zero_padding = 0; + result_33.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_33) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)post_mix)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_34; + result_34.type_index = kTVMFFINone; + result_34.zero_padding = 0; + result_34.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_34) != 0) { + return -1; + } + } + if ((((DLTensor*)post_mix)[0].device.device_id) != (((DLTensor*)comb_mix)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_35; + result_35.type_index = kTVMFFINone; + result_35.zero_padding = 0; + result_35.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_35) != 0) { + return -1; + } + } + if ((((DLTensor*)post_mix)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_36; + result_36.type_index = kTVMFFINone; + result_36.zero_padding = 0; + result_36.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_36) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (post_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_37; + result_37.type_index = kTVMFFINone; + result_37.zero_padding = 0; + result_37.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_37) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)x_in)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)x_in)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)x_in)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"x_in"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)x_in)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)x_in)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)x_in)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_38; + result_38.type_index = kTVMFFINone; + result_38.zero_padding = 0; + result_38.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_38) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_fused_tilelang_comb_mix_shape)[0]) != ((int32_t)((int64_t*)mhc_fused_tilelang_x_in_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"x_in"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_fused_tilelang_x_in_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_fused_tilelang_comb_mix_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_39; + result_39.type_index = kTVMFFINone; + result_39.zero_padding = 0; + result_39.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_39) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_fused_tilelang_x_in_shape)[1]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"x_in"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_fused_tilelang_x_in_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_40; + result_40.type_index = kTVMFFINone; + result_40.zero_padding = 0; + result_40.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_40) != 0) { + return -1; + } + } + int32_t condval_13; + if ((mhc_fused_tilelang_x_in_strides == NULL)) { + condval_13 = 1; + } else { + condval_13 = ((int32_t)((int64_t*)mhc_fused_tilelang_x_in_strides)[1]); + } + if (condval_13 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"x_in"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_14; + if ((mhc_fused_tilelang_x_in_strides == NULL)) { + condval_14 = 1; + } else { + condval_14 = ((int32_t)((int64_t*)mhc_fused_tilelang_x_in_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_14); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_41; + result_41.type_index = kTVMFFINone; + result_41.zero_padding = 0; + result_41.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_41) != 0) { + return -1; + } + } + int32_t condval_15; + if ((mhc_fused_tilelang_x_in_strides == NULL)) { + condval_15 = 1; + } else { + condval_15 = ((int32_t)((int64_t*)mhc_fused_tilelang_x_in_strides)[0]); + } + if ((condval_15 != 4096) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"x_in"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_42; + result_42.type_index = kTVMFFINone; + result_42.zero_padding = 0; + result_42.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_42) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)x_in)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"x_in"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)x_in)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_43; + result_43.type_index = kTVMFFINone; + result_43.zero_padding = 0; + result_43.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_43) != 0) { + return -1; + } + } + if ((((DLTensor*)x_in)[0].device.device_id) != (((DLTensor*)comb_mix)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"x_in"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)x_in)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_44; + result_44.type_index = kTVMFFINone; + result_44.zero_padding = 0; + result_44.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_44) != 0) { + return -1; + } + } + if ((((DLTensor*)x_in)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"x_in"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)x_in)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_45; + result_45.type_index = kTVMFFINone; + result_45.zero_padding = 0; + result_45.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_45) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (x_in_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"x_in"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_46; + result_46.type_index = kTVMFFINone; + result_46.zero_padding = 0; + result_46.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_46) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)weight_t)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)weight_t)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)weight_t)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"weight_t"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)weight_t)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)weight_t)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)weight_t)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_47; + result_47.type_index = kTVMFFINone; + result_47.zero_padding = 0; + result_47.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_47) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_fused_tilelang_weight_t_shape)[0]) != 24) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"weight_t"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)24; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_fused_tilelang_weight_t_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_48; + result_48.type_index = kTVMFFINone; + result_48.zero_padding = 0; + result_48.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_48) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_fused_tilelang_weight_t_shape)[1]) != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"weight_t"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_fused_tilelang_weight_t_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_49; + result_49.type_index = kTVMFFINone; + result_49.zero_padding = 0; + result_49.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_49) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_fused_tilelang_weight_t_shape)[2]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"weight_t"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_fused_tilelang_weight_t_shape)[2])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_50; + result_50.type_index = kTVMFFINone; + result_50.zero_padding = 0; + result_50.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_50) != 0) { + return -1; + } + } + int32_t condval_16; + if ((mhc_fused_tilelang_weight_t_strides == NULL)) { + condval_16 = 1; + } else { + condval_16 = ((int32_t)((int64_t*)mhc_fused_tilelang_weight_t_strides)[2]); + } + if (condval_16 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"weight_t"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_17; + if ((mhc_fused_tilelang_weight_t_strides == NULL)) { + condval_17 = 1; + } else { + condval_17 = ((int32_t)((int64_t*)mhc_fused_tilelang_weight_t_strides)[2]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_17); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_51; + result_51.type_index = kTVMFFINone; + result_51.zero_padding = 0; + result_51.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_51) != 0) { + return -1; + } + } + int32_t condval_18; + if ((mhc_fused_tilelang_weight_t_strides == NULL)) { + condval_18 = 1; + } else { + condval_18 = ((int32_t)((int64_t*)mhc_fused_tilelang_weight_t_strides)[1]); + } + if (condval_18 != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"weight_t"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_19; + if ((mhc_fused_tilelang_weight_t_strides == NULL)) { + condval_19 = 1; + } else { + condval_19 = ((int32_t)((int64_t*)mhc_fused_tilelang_weight_t_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_19); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_52; + result_52.type_index = kTVMFFINone; + result_52.zero_padding = 0; + result_52.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_52) != 0) { + return -1; + } + } + int32_t condval_20; + if ((mhc_fused_tilelang_weight_t_strides == NULL)) { + condval_20 = 1; + } else { + condval_20 = ((int32_t)((int64_t*)mhc_fused_tilelang_weight_t_strides)[0]); + } + if (condval_20 != 16384) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"weight_t"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)16384; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_21; + if ((mhc_fused_tilelang_weight_t_strides == NULL)) { + condval_21 = 1; + } else { + condval_21 = ((int32_t)((int64_t*)mhc_fused_tilelang_weight_t_strides)[0]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_21); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_53; + result_53.type_index = kTVMFFINone; + result_53.zero_padding = 0; + result_53.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_53) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)weight_t)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"weight_t"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)weight_t)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_54; + result_54.type_index = kTVMFFINone; + result_54.zero_padding = 0; + result_54.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_54) != 0) { + return -1; + } + } + if ((((DLTensor*)weight_t)[0].device.device_id) != (((DLTensor*)comb_mix)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"weight_t"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)weight_t)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_55; + result_55.type_index = kTVMFFINone; + result_55.zero_padding = 0; + result_55.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_55) != 0) { + return -1; + } + } + if ((((DLTensor*)weight_t)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"weight_t"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)weight_t)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_56; + result_56.type_index = kTVMFFINone; + result_56.zero_padding = 0; + result_56.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_56) != 0) { + return -1; + } + } + if (weight_t_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"weight_t"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_57; + result_57.type_index = kTVMFFINone; + result_57.zero_padding = 0; + result_57.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_57) != 0) { + return -1; + } + } + if ((((((DLTensor*)yp_out)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)yp_out)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)yp_out)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"yp_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)yp_out)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)yp_out)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)yp_out)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_58; + result_58.type_index = kTVMFFINone; + result_58.zero_padding = 0; + result_58.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_58) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_fused_tilelang_comb_mix_shape)[0]) != ((int32_t)((int64_t*)mhc_fused_tilelang_yp_out_shape)[1])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"yp_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_fused_tilelang_yp_out_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_fused_tilelang_comb_mix_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_59; + result_59.type_index = kTVMFFINone; + result_59.zero_padding = 0; + result_59.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_59) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_fused_tilelang_yp_out_shape)[2]) != 24) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"yp_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)24; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_fused_tilelang_yp_out_shape)[2])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_60; + result_60.type_index = kTVMFFINone; + result_60.zero_padding = 0; + result_60.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_60) != 0) { + return -1; + } + } + int32_t condval_22; + if ((mhc_fused_tilelang_yp_out_strides == NULL)) { + condval_22 = 1; + } else { + condval_22 = ((int32_t)((int64_t*)mhc_fused_tilelang_yp_out_strides)[2]); + } + if (condval_22 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"yp_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_23; + if ((mhc_fused_tilelang_yp_out_strides == NULL)) { + condval_23 = 1; + } else { + condval_23 = ((int32_t)((int64_t*)mhc_fused_tilelang_yp_out_strides)[2]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_23); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_61; + result_61.type_index = kTVMFFINone; + result_61.zero_padding = 0; + result_61.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_61) != 0) { + return -1; + } + } + int32_t condval_24; + if ((mhc_fused_tilelang_yp_out_strides == NULL)) { + condval_24 = 1; + } else { + condval_24 = ((int32_t)((int64_t*)mhc_fused_tilelang_yp_out_strides)[1]); + } + if ((condval_24 != 24) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"yp_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_62; + result_62.type_index = kTVMFFINone; + result_62.zero_padding = 0; + result_62.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_62) != 0) { + return -1; + } + } + int32_t condval_25; + if ((mhc_fused_tilelang_yp_out_strides == NULL)) { + condval_25 = 1; + } else { + condval_25 = ((int32_t)((int64_t*)mhc_fused_tilelang_yp_out_strides)[0]); + } + if ((((num_tokens * 24) != condval_25) && (num_tokens != 0)) && (split_k != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"yp_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_63; + result_63.type_index = kTVMFFINone; + result_63.zero_padding = 0; + result_63.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_63) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)yp_out)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"yp_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)yp_out)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_64; + result_64.type_index = kTVMFFINone; + result_64.zero_padding = 0; + result_64.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_64) != 0) { + return -1; + } + } + if ((((DLTensor*)yp_out)[0].device.device_id) != (((DLTensor*)comb_mix)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"yp_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)yp_out)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_65; + result_65.type_index = kTVMFFINone; + result_65.zero_padding = 0; + result_65.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_65) != 0) { + return -1; + } + } + if ((((DLTensor*)yp_out)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"yp_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)yp_out)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_66; + result_66.type_index = kTVMFFINone; + result_66.zero_padding = 0; + result_66.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_66) != 0) { + return -1; + } + } + if ((split_k != 0) && (num_tokens != 0)) { + if (yp_out_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"yp_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_67; + result_67.type_index = kTVMFFINone; + result_67.zero_padding = 0; + result_67.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_67) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)rp_out)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)rp_out)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)rp_out)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"rp_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)rp_out)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)rp_out)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)rp_out)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_68; + result_68.type_index = kTVMFFINone; + result_68.zero_padding = 0; + result_68.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_68) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_fused_tilelang_yp_out_shape)[0]) != ((int32_t)((int64_t*)mhc_fused_tilelang_rp_out_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"rp_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_fused_tilelang_rp_out_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_fused_tilelang_yp_out_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_69; + result_69.type_index = kTVMFFINone; + result_69.zero_padding = 0; + result_69.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_69) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_fused_tilelang_comb_mix_shape)[0]) != ((int32_t)((int64_t*)mhc_fused_tilelang_rp_out_shape)[1])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"rp_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_fused_tilelang_rp_out_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_fused_tilelang_comb_mix_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_70; + result_70.type_index = kTVMFFINone; + result_70.zero_padding = 0; + result_70.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_70) != 0) { + return -1; + } + } + int32_t condval_26; + if ((mhc_fused_tilelang_rp_out_strides == NULL)) { + condval_26 = 1; + } else { + condval_26 = ((int32_t)((int64_t*)mhc_fused_tilelang_rp_out_strides)[1]); + } + if ((condval_26 != 1) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"rp_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_71; + result_71.type_index = kTVMFFINone; + result_71.zero_padding = 0; + result_71.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_71) != 0) { + return -1; + } + } + int32_t condval_27; + if ((mhc_fused_tilelang_rp_out_strides == NULL)) { + condval_27 = 1; + } else { + condval_27 = ((int32_t)((int64_t*)mhc_fused_tilelang_rp_out_strides)[0]); + } + if (((((int32_t)((int64_t*)mhc_fused_tilelang_comb_mix_shape)[0]) != condval_27) && (((int32_t)((int64_t*)mhc_fused_tilelang_comb_mix_shape)[0]) != 0)) && (split_k != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"rp_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_72; + result_72.type_index = kTVMFFINone; + result_72.zero_padding = 0; + result_72.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_72) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)rp_out)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"rp_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)rp_out)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_73; + result_73.type_index = kTVMFFINone; + result_73.zero_padding = 0; + result_73.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_73) != 0) { + return -1; + } + } + if ((((DLTensor*)rp_out)[0].device.device_id) != (((DLTensor*)comb_mix)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"rp_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)rp_out)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_74; + result_74.type_index = kTVMFFINone; + result_74.zero_padding = 0; + result_74.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_74) != 0) { + return -1; + } + } + if ((((DLTensor*)rp_out)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"rp_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)rp_out)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_75; + result_75.type_index = kTVMFFINone; + result_75.zero_padding = 0; + result_75.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_75) != 0) { + return -1; + } + } + if ((split_k != 0) && (num_tokens != 0)) { + if (rp_out_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"rp_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_76; + result_76.type_index = kTVMFFINone; + result_76.zero_padding = 0; + result_76.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_76) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)residual_out)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)residual_out)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)residual_out)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)residual_out)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual_out)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)residual_out)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_77; + result_77.type_index = kTVMFFINone; + result_77.zero_padding = 0; + result_77.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_77) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_fused_tilelang_comb_mix_shape)[0]) != ((int32_t)((int64_t*)mhc_fused_tilelang_residual_out_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_fused_tilelang_residual_out_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_fused_tilelang_comb_mix_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_78; + result_78.type_index = kTVMFFINone; + result_78.zero_padding = 0; + result_78.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_78) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_fused_tilelang_residual_out_shape)[1]) != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_fused_tilelang_residual_out_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_79; + result_79.type_index = kTVMFFINone; + result_79.zero_padding = 0; + result_79.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_79) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_fused_tilelang_residual_out_shape)[2]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_fused_tilelang_residual_out_shape)[2])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_80; + result_80.type_index = kTVMFFINone; + result_80.zero_padding = 0; + result_80.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_80) != 0) { + return -1; + } + } + int32_t condval_28; + if ((mhc_fused_tilelang_residual_out_strides == NULL)) { + condval_28 = 1; + } else { + condval_28 = ((int32_t)((int64_t*)mhc_fused_tilelang_residual_out_strides)[2]); + } + if (condval_28 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_29; + if ((mhc_fused_tilelang_residual_out_strides == NULL)) { + condval_29 = 1; + } else { + condval_29 = ((int32_t)((int64_t*)mhc_fused_tilelang_residual_out_strides)[2]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_29); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_81; + result_81.type_index = kTVMFFINone; + result_81.zero_padding = 0; + result_81.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_81) != 0) { + return -1; + } + } + int32_t condval_30; + if ((mhc_fused_tilelang_residual_out_strides == NULL)) { + condval_30 = 1; + } else { + condval_30 = ((int32_t)((int64_t*)mhc_fused_tilelang_residual_out_strides)[1]); + } + if (condval_30 != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_31; + if ((mhc_fused_tilelang_residual_out_strides == NULL)) { + condval_31 = 1; + } else { + condval_31 = ((int32_t)((int64_t*)mhc_fused_tilelang_residual_out_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_31); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_82; + result_82.type_index = kTVMFFINone; + result_82.zero_padding = 0; + result_82.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_82) != 0) { + return -1; + } + } + int32_t condval_32; + if ((mhc_fused_tilelang_residual_out_strides == NULL)) { + condval_32 = 1; + } else { + condval_32 = ((int32_t)((int64_t*)mhc_fused_tilelang_residual_out_strides)[0]); + } + if ((condval_32 != 16384) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_83; + result_83.type_index = kTVMFFINone; + result_83.zero_padding = 0; + result_83.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_83) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)residual_out)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual_out)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_84; + result_84.type_index = kTVMFFINone; + result_84.zero_padding = 0; + result_84.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_84) != 0) { + return -1; + } + } + if ((((DLTensor*)residual_out)[0].device.device_id) != (((DLTensor*)comb_mix)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)residual_out)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_85; + result_85.type_index = kTVMFFINone; + result_85.zero_padding = 0; + result_85.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_85) != 0) { + return -1; + } + } + if ((((DLTensor*)residual_out)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual_out)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_86; + result_86.type_index = kTVMFFINone; + result_86.zero_padding = 0; + result_86.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_86) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (residual_out_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_87; + result_87.type_index = kTVMFFINone; + result_87.zero_padding = 0; + result_87.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_87) != 0) { + return -1; + } + } + } else { + } + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = ((int64_t)2); + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = ((int64_t)dev_id); + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + if (__tvm_set_device_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_set_device", &__tvm_set_device_packed) != 0) { + return -1; + } + } + TVMFFIAny result_88; + result_88.type_index = kTVMFFINone; + result_88.zero_padding = 0; + result_88.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_set_device_packed, (TVMFFIAny*) stack_ffi_any, 2, &result_88) != 0) { + return -1; + } + if (comb_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = comb_mix_1; + if (post_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = post_mix_1; + if (residual_in_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = residual_in_1; + if (residual_out_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_ptr) = residual_out_1; + if (rp_out_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_ptr) = rp_out_1; + if (weight_t_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_ptr) = weight_t_1; + if (x_in_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_ptr) = x_in_1; + if (yp_out_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_ptr) = yp_out_1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = ((int64_t)num_tokens); + (((TVMFFIAny*)stack_ffi_any)[9].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[9].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[9].v_int64) = ((int64_t)split_k); + (((TVMFFIAny*)stack_ffi_any)[10].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[10].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[10].v_int64) = ((int64_t)num_tokens); + (((TVMFFIAny*)stack_ffi_any)[11].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[11].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[11].v_int64) = ((int64_t)8); + (((TVMFFIAny*)stack_ffi_any)[12].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[12].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[12].v_int64) = ((int64_t)split_k); + (((TVMFFIAny*)stack_ffi_any)[13].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[13].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[13].v_int64) = ((int64_t)256); + (((TVMFFIAny*)stack_ffi_any)[14].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[14].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[14].v_int64) = ((int64_t)1); + (((TVMFFIAny*)stack_ffi_any)[15].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[15].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[15].v_int64) = ((int64_t)1); + (((TVMFFIAny*)stack_ffi_any)[16].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[16].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[16].v_int64) = ((int64_t)208); + (((TVMFFIAny*)stack_ffi_any)[17].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[17].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[17].v_int64) = (int64_t)0; + if (mhc_fused_tilelang_kernel_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "mhc_fused_tilelang_kernel", &mhc_fused_tilelang_kernel_packed) != 0) { + return -1; + } + } + TVMFFIAny result_89; + result_89.type_index = kTVMFFINone; + result_89.zero_padding = 0; + result_89.v_int64 = 0; + if (TVMFFIFunctionCall(mhc_fused_tilelang_kernel_packed, (TVMFFIAny*) stack_ffi_any, 17, &result_89) != 0) { + return -1; + } + return 0; +} + +// CodegenC: NOTE: Auto-generated entry function +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_main(void* self, void* args,int num_args, void* result) { + return __tvm_ffi_mhc_fused_tilelang(self, args, num_args, result); +} diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/94b96c76ed4b18c5a1404f5c71d4cc9c8be8d3d582285c754714502150b21353/params.pkl b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/94b96c76ed4b18c5a1404f5c71d4cc9c8be8d3d582285c754714502150b21353/params.pkl new file mode 100644 index 0000000..2a45bcd Binary files /dev/null and b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/94b96c76ed4b18c5a1404f5c71d4cc9c8be8d3d582285c754714502150b21353/params.pkl differ diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/96e9b9b5cf258ab70fb96c06c4ba12fa70819bfb1b8c147e903abf420053524b/device_kernel.cu b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/96e9b9b5cf258ab70fb96c06c4ba12fa70819bfb1b8c147e903abf420053524b/device_kernel.cu new file mode 100644 index 0000000..3b2e8c5 --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/96e9b9b5cf258ab70fb96c06c4ba12fa70819bfb1b8c147e903abf420053524b/device_kernel.cu @@ -0,0 +1,102 @@ +#include +#include +#include +#include +#include +#include +#ifdef ENABLE_BF16 +#include +#endif + +extern "C" __global__ void mhc_fused_tilelang_kernel(const float* comb_mix, const float* post_mix, const bfloat16_t* residual_in, bfloat16_t* residual_out, float* rp_out, const float* weight_t, const bfloat16_t* x_in, float* yp_out, int num_tokens, int split_k); +extern "C" __global__ void __launch_bounds__(256, 1) mhc_fused_tilelang_kernel(const float* comb_mix, const float* post_mix, const bfloat16_t* residual_in, bfloat16_t* residual_out, float* rp_out, const float* weight_t, const bfloat16_t* x_in, float* yp_out, int num_tokens, int split_k) { + extern __shared__ __align__(1024) uchar buf_dyn_shmem[]; + float acc[2]; + float sqr[1]; + float pm[4]; + float cm[16]; + float new_r[4]; + float v = 0x0p+0f/*0.000000e+00*/; + float v2 = 0x0p+0f/*0.000000e+00*/; + float broadcast_var = 0x0p+0f/*0.000000e+00*/; + *(float2*)(acc + 0) = make_float2(broadcast_var, broadcast_var); + sqr[0] = 0x0p+0f/*0.000000e+00*/; + cudaGridDependencySynchronize(); + if (((int)threadIdx.x) < 4) { + ((float*)buf_dyn_shmem)[((int)threadIdx.x)] = post_mix[((((int64_t)((int)blockIdx.x)) * (int64_t)4) + ((int64_t)((int)threadIdx.x)))]; + } + if (((int)threadIdx.x) < 16) { + ((float*)buf_dyn_shmem)[(((int)threadIdx.x) + 4)] = comb_mix[((((int64_t)((int)blockIdx.x)) * (int64_t)16) + ((int64_t)((int)threadIdx.x)))]; + } + __syncthreads(); + #pragma unroll + for (int j = 0; j < 4; ++j) { + pm[j] = ((float*)buf_dyn_shmem)[j]; + } + #pragma unroll + for (int j_1 = 0; j_1 < 4; ++j_1) { + #pragma unroll + for (int k = 0; k < 4; ++k) { + cm[((k * 4) + j_1)] = ((float*)buf_dyn_shmem)[(((k * 4) + j_1) + 4)]; + } + } + for (int it = 0; it < ((4096 / split_k) >> 8); ++it) { + #pragma unroll + for (int j_2 = 0; j_2 < 4; ++j_2) { + new_r[j_2] = (pm[j_2] * ((float)x_in[((((((int64_t)((int)blockIdx.x)) * (int64_t)4096) + (((int64_t)it) * (int64_t)256)) + (((int64_t)((int)blockIdx.z)) * ((int64_t)4096 / ((int64_t)split_k)))) + ((int64_t)((int)threadIdx.x)))])); + #pragma unroll + for (int k_1 = 0; k_1 < 4; ++k_1) { + new_r[j_2] = (new_r[j_2] + (cm[((k_1 * 4) + j_2)] * ((float)residual_in[(((((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + (((int64_t)k_1) * (int64_t)4096)) + (((int64_t)it) * (int64_t)256)) + (((int64_t)((int)blockIdx.z)) * ((int64_t)4096 / ((int64_t)split_k)))) + ((int64_t)((int)threadIdx.x)))]))); + } + } + if (((int)blockIdx.y) == 0) { + #pragma unroll + for (int j_3 = 0; j_3 < 4; ++j_3) { + residual_out[(((((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + (((int64_t)j_3) * (int64_t)4096)) + (((int64_t)it) * (int64_t)256)) + (((int64_t)((int)blockIdx.z)) * ((int64_t)4096 / ((int64_t)split_k)))) + ((int64_t)((int)threadIdx.x)))] = ((bfloat16_t)new_r[j_3]); + sqr[0] = (sqr[0] + (new_r[j_3] * new_r[j_3])); + } + } + #pragma unroll + for (int n = 0; n < 2; ++n) { + #pragma unroll + for (int j_4 = 0; j_4 < 4; ++j_4) { + acc[n] = (acc[n] + (weight_t[((((((((int64_t)((int)blockIdx.y)) * (int64_t)32768) + (((int64_t)n) * (int64_t)16384)) + (((int64_t)j_4) * (int64_t)4096)) + (((int64_t)it) * (int64_t)256)) + (((int64_t)((int)blockIdx.z)) * ((int64_t)4096 / ((int64_t)split_k)))) + ((int64_t)((int)threadIdx.x)))] * new_r[j_4])); + } + } + } + #pragma unroll + for (int n_1 = 0; n_1 < 2; ++n_1) { + acc[n_1] = tl::warp_reduce_sum(acc[n_1]); + } + if (((int)blockIdx.y) == 0) { + sqr[0] = tl::warp_reduce_sum(sqr[0]); + } + if ((((int)threadIdx.x) % 32) == 0) { + #pragma unroll + for (int n_2 = 0; n_2 < 2; ++n_2) { + ((float*)buf_dyn_shmem)[((((((int)threadIdx.x) >> 5) * 3) + n_2) + 20)] = acc[n_2]; + } + if (((int)blockIdx.y) == 0) { + ((float*)buf_dyn_shmem)[(((((int)threadIdx.x) >> 5) * 3) + 22)] = sqr[0]; + } + } + __syncthreads(); + if ((((int)threadIdx.x) >> 5) == 0) { + if ((((int)threadIdx.x) & 31) < 2) { + #pragma unroll + for (int w = 0; w < 8; ++w) { + v = (v + ((float*)buf_dyn_shmem)[(((w * 3) + (((int)threadIdx.x) & 31)) + 20)]); + } + yp_out[((((((int64_t)((int)blockIdx.x)) * (int64_t)24) + ((((int64_t)((int)blockIdx.z)) * ((int64_t)num_tokens)) * (int64_t)24)) + (((int64_t)((int)blockIdx.y)) * (int64_t)2)) + (((int64_t)((int)threadIdx.x)) & (int64_t)31))] = v; + } + if ((((int)blockIdx.y) == 0) && ((((int)threadIdx.x) % 32) == 0)) { + #pragma unroll + for (int w_1 = 0; w_1 < 8; ++w_1) { + v2 = (v2 + ((float*)buf_dyn_shmem)[((w_1 * 3) + 22)]); + } + rp_out[((((int64_t)((int)blockIdx.z)) * ((int64_t)num_tokens)) + ((int64_t)((int)blockIdx.x)))] = v2; + } + } + cudaTriggerProgrammaticLaunchCompletion(); +} + diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/96e9b9b5cf258ab70fb96c06c4ba12fa70819bfb1b8c147e903abf420053524b/host_kernel.cu b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/96e9b9b5cf258ab70fb96c06c4ba12fa70819bfb1b8c147e903abf420053524b/host_kernel.cu new file mode 100644 index 0000000..0a225e6 --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/96e9b9b5cf258ab70fb96c06c4ba12fa70819bfb1b8c147e903abf420053524b/host_kernel.cu @@ -0,0 +1,3435 @@ +// tilelang target: c -keys=cpu +#define TVM_EXPORTS +#include "tvm/runtime/base.h" +#include "tvm/runtime/c_backend_api.h" +#include "tvm/ffi/c_api.h" +#include +#include +#include +#ifdef __OBJC__ +#include "tvm/runtime/device_api.h" +#include "tvm/ffi/function.h" +#include +#include +#include +#endif +void* __tvm_ffi__library_ctx = NULL; +static void* __tvm_error_ndim_mismatch_packed = NULL; +static void* __tvm_error_dtype_mismatch_packed = NULL; +static void* __tvm_error_expect_eq_packed = NULL; +static void* __tvm_error_constraint_violation_packed = NULL; +static void* __tvm_error_byte_offset_mismatch_packed = NULL; +static void* __tvm_error_device_type_mismatch_packed = NULL; +static void* __tvm_error_null_ptr_packed = NULL; +static void* __tvm_set_device_packed = NULL; +static void* mhc_fused_tilelang_kernel_packed = NULL; +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_mhc_fused_tilelang(void* self_handle, void* args, int32_t num_args, void* result); +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_mhc_fused_tilelang(void* self_handle, void* args, int32_t num_args, void* result) { + __attribute__((aligned(64))) TVMFFIAny stack[18]; + void* stack_ffi_any = stack; + if (!((num_args == 8))) { + char __tvm_assert_msg_buf[512]; + snprintf(__tvm_assert_msg_buf, 512, "%s; expected: %lld, got: %lld", "mhc_fused_tilelang: num_args should be 8", (long long)(num_args), (long long)(8)); + TVMFFIErrorSetRaisedFromCStr("RuntimeError", __tvm_assert_msg_buf); + return -1; + } + if (!(!(args == NULL))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_fused_tilelang: args pointer is NULL"); + return -1; + } + int32_t comb_mix_type_index = (((TVMFFIAny*)args)[0].type_index); + if (!(((((comb_mix_type_index == 0) || (comb_mix_type_index == 4)) || (comb_mix_type_index == 7)) || (64 <= comb_mix_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_fused_tilelang input comb_mix expected pointer or tensor handle"); + return -1; + } + int32_t residual_in_type_index = (((TVMFFIAny*)args)[1].type_index); + if (!(((((residual_in_type_index == 0) || (residual_in_type_index == 4)) || (residual_in_type_index == 7)) || (64 <= residual_in_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_fused_tilelang input residual_in expected pointer or tensor handle"); + return -1; + } + int32_t post_mix_type_index = (((TVMFFIAny*)args)[2].type_index); + if (!(((((post_mix_type_index == 0) || (post_mix_type_index == 4)) || (post_mix_type_index == 7)) || (64 <= post_mix_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_fused_tilelang input post_mix expected pointer or tensor handle"); + return -1; + } + int32_t x_in_type_index = (((TVMFFIAny*)args)[3].type_index); + if (!(((((x_in_type_index == 0) || (x_in_type_index == 4)) || (x_in_type_index == 7)) || (64 <= x_in_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_fused_tilelang input x_in expected pointer or tensor handle"); + return -1; + } + int32_t weight_t_type_index = (((TVMFFIAny*)args)[4].type_index); + if (!(((((weight_t_type_index == 0) || (weight_t_type_index == 4)) || (weight_t_type_index == 7)) || (64 <= weight_t_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_fused_tilelang input weight_t expected pointer or tensor handle"); + return -1; + } + int32_t yp_out_type_index = (((TVMFFIAny*)args)[5].type_index); + if (!(((((yp_out_type_index == 0) || (yp_out_type_index == 4)) || (yp_out_type_index == 7)) || (64 <= yp_out_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_fused_tilelang input yp_out expected pointer or tensor handle"); + return -1; + } + int32_t rp_out_type_index = (((TVMFFIAny*)args)[6].type_index); + if (!(((((rp_out_type_index == 0) || (rp_out_type_index == 4)) || (rp_out_type_index == 7)) || (64 <= rp_out_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_fused_tilelang input rp_out expected pointer or tensor handle"); + return -1; + } + int32_t residual_out_type_index = (((TVMFFIAny*)args)[7].type_index); + if (!(((((residual_out_type_index == 0) || (residual_out_type_index == 4)) || (residual_out_type_index == 7)) || (64 <= residual_out_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_fused_tilelang input residual_out expected pointer or tensor handle"); + return -1; + } + void* comb_mix = ((comb_mix_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[0].v_ptr) + 24)) : (((TVMFFIAny*)args)[0].v_ptr)); + void* residual_in = ((residual_in_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[1].v_ptr) + 24)) : (((TVMFFIAny*)args)[1].v_ptr)); + void* post_mix = ((post_mix_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[2].v_ptr) + 24)) : (((TVMFFIAny*)args)[2].v_ptr)); + void* x_in = ((x_in_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[3].v_ptr) + 24)) : (((TVMFFIAny*)args)[3].v_ptr)); + void* weight_t = ((weight_t_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[4].v_ptr) + 24)) : (((TVMFFIAny*)args)[4].v_ptr)); + void* yp_out = ((yp_out_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[5].v_ptr) + 24)) : (((TVMFFIAny*)args)[5].v_ptr)); + void* rp_out = ((rp_out_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[6].v_ptr) + 24)) : (((TVMFFIAny*)args)[6].v_ptr)); + void* residual_out = ((residual_out_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[7].v_ptr) + 24)) : (((TVMFFIAny*)args)[7].v_ptr)); + bool mhc_fused_tilelang_comb_mix_is_null = (comb_mix == NULL); + if (!(!mhc_fused_tilelang_comb_mix_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_fused_tilelang.comb_mix is expected to have non-NULL pointer"); + return -1; + } + bool mhc_fused_tilelang_residual_in_is_null = (residual_in == NULL); + if (!(!mhc_fused_tilelang_residual_in_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_fused_tilelang.residual_in is expected to have non-NULL pointer"); + return -1; + } + bool mhc_fused_tilelang_post_mix_is_null = (post_mix == NULL); + if (!(!mhc_fused_tilelang_post_mix_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_fused_tilelang.post_mix is expected to have non-NULL pointer"); + return -1; + } + bool mhc_fused_tilelang_x_in_is_null = (x_in == NULL); + if (!(!mhc_fused_tilelang_x_in_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_fused_tilelang.x_in is expected to have non-NULL pointer"); + return -1; + } + bool mhc_fused_tilelang_weight_t_is_null = (weight_t == NULL); + if (!(!mhc_fused_tilelang_weight_t_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_fused_tilelang.weight_t is expected to have non-NULL pointer"); + return -1; + } + bool mhc_fused_tilelang_yp_out_is_null = (yp_out == NULL); + if (!(!mhc_fused_tilelang_yp_out_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_fused_tilelang.yp_out is expected to have non-NULL pointer"); + return -1; + } + bool mhc_fused_tilelang_rp_out_is_null = (rp_out == NULL); + if (!(!mhc_fused_tilelang_rp_out_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_fused_tilelang.rp_out is expected to have non-NULL pointer"); + return -1; + } + bool mhc_fused_tilelang_residual_out_is_null = (residual_out == NULL); + if (!(!mhc_fused_tilelang_residual_out_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_fused_tilelang.residual_out is expected to have non-NULL pointer"); + return -1; + } + void* mhc_fused_tilelang_comb_mix_shape = (((DLTensor*)comb_mix)[0].shape); + void* mhc_fused_tilelang_residual_in_shape = (((DLTensor*)residual_in)[0].shape); + void* mhc_fused_tilelang_post_mix_shape = (((DLTensor*)post_mix)[0].shape); + void* mhc_fused_tilelang_x_in_shape = (((DLTensor*)x_in)[0].shape); + void* mhc_fused_tilelang_weight_t_shape = (((DLTensor*)weight_t)[0].shape); + void* mhc_fused_tilelang_yp_out_shape = (((DLTensor*)yp_out)[0].shape); + void* mhc_fused_tilelang_rp_out_shape = (((DLTensor*)rp_out)[0].shape); + void* mhc_fused_tilelang_residual_out_shape = (((DLTensor*)residual_out)[0].shape); + if ((((DLTensor*)comb_mix)[0].ndim) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_1; + result_1.type_index = kTVMFFINone; + result_1.zero_padding = 0; + result_1.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_1) != 0) { + return -1; + } + } + if (!((bool)1)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "Symbolic shape variable num_tokens requires at least one non-null buffer among: mhc_fused_tilelang.comb_mix, mhc_fused_tilelang.residual_in, mhc_fused_tilelang.post_mix, mhc_fused_tilelang.x_in, mhc_fused_tilelang.yp_out, mhc_fused_tilelang.rp_out, mhc_fused_tilelang.residual_out"); + return -1; + } + int32_t num_tokens = ((int32_t)((int64_t*)mhc_fused_tilelang_comb_mix_shape)[0]); + void* mhc_fused_tilelang_comb_mix_strides = (((DLTensor*)comb_mix)[0].strides); + int32_t dev_id = (((DLTensor*)comb_mix)[0].device.device_id); + void* comb_mix_1 = (((DLTensor*)comb_mix)[0].data); + if ((((DLTensor*)residual_in)[0].ndim) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual_in"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual_in)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_2; + result_2.type_index = kTVMFFINone; + result_2.zero_padding = 0; + result_2.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_2) != 0) { + return -1; + } + } + void* mhc_fused_tilelang_residual_in_strides = (((DLTensor*)residual_in)[0].strides); + void* residual_in_1 = (((DLTensor*)residual_in)[0].data); + if ((((DLTensor*)post_mix)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_3; + result_3.type_index = kTVMFFINone; + result_3.zero_padding = 0; + result_3.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_3) != 0) { + return -1; + } + } + void* mhc_fused_tilelang_post_mix_strides = (((DLTensor*)post_mix)[0].strides); + void* post_mix_1 = (((DLTensor*)post_mix)[0].data); + if ((((DLTensor*)x_in)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"x_in"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)x_in)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_4; + result_4.type_index = kTVMFFINone; + result_4.zero_padding = 0; + result_4.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_4) != 0) { + return -1; + } + } + void* mhc_fused_tilelang_x_in_strides = (((DLTensor*)x_in)[0].strides); + void* x_in_1 = (((DLTensor*)x_in)[0].data); + if ((((DLTensor*)weight_t)[0].ndim) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"weight_t"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)weight_t)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_5; + result_5.type_index = kTVMFFINone; + result_5.zero_padding = 0; + result_5.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_5) != 0) { + return -1; + } + } + void* mhc_fused_tilelang_weight_t_strides = (((DLTensor*)weight_t)[0].strides); + void* weight_t_1 = (((DLTensor*)weight_t)[0].data); + if ((((DLTensor*)yp_out)[0].ndim) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"yp_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)yp_out)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_6; + result_6.type_index = kTVMFFINone; + result_6.zero_padding = 0; + result_6.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_6) != 0) { + return -1; + } + } + if (!((bool)1)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "Symbolic shape variable split_k requires at least one non-null buffer among: mhc_fused_tilelang.yp_out, mhc_fused_tilelang.rp_out"); + return -1; + } + int32_t split_k = ((int32_t)((int64_t*)mhc_fused_tilelang_yp_out_shape)[0]); + void* mhc_fused_tilelang_yp_out_strides = (((DLTensor*)yp_out)[0].strides); + void* yp_out_1 = (((DLTensor*)yp_out)[0].data); + if ((((DLTensor*)rp_out)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"rp_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)rp_out)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_7; + result_7.type_index = kTVMFFINone; + result_7.zero_padding = 0; + result_7.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_7) != 0) { + return -1; + } + } + void* mhc_fused_tilelang_rp_out_strides = (((DLTensor*)rp_out)[0].strides); + void* rp_out_1 = (((DLTensor*)rp_out)[0].data); + if ((((DLTensor*)residual_out)[0].ndim) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual_out)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_8; + result_8.type_index = kTVMFFINone; + result_8.zero_padding = 0; + result_8.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_8) != 0) { + return -1; + } + } + void* mhc_fused_tilelang_residual_out_strides = (((DLTensor*)residual_out)[0].strides); + void* residual_out_1 = (((DLTensor*)residual_out)[0].data); + if ((((((DLTensor*)comb_mix)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)comb_mix)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)comb_mix)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_9; + result_9.type_index = kTVMFFINone; + result_9.zero_padding = 0; + result_9.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_9) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_fused_tilelang_comb_mix_shape)[1]) != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_fused_tilelang_comb_mix_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_10; + result_10.type_index = kTVMFFINone; + result_10.zero_padding = 0; + result_10.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_10) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_fused_tilelang_comb_mix_shape)[2]) != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_fused_tilelang_comb_mix_shape)[2])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_11; + result_11.type_index = kTVMFFINone; + result_11.zero_padding = 0; + result_11.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_11) != 0) { + return -1; + } + } + int32_t condval; + if ((mhc_fused_tilelang_comb_mix_strides == NULL)) { + condval = 1; + } else { + condval = ((int32_t)((int64_t*)mhc_fused_tilelang_comb_mix_strides)[2]); + } + if (condval != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_1; + if ((mhc_fused_tilelang_comb_mix_strides == NULL)) { + condval_1 = 1; + } else { + condval_1 = ((int32_t)((int64_t*)mhc_fused_tilelang_comb_mix_strides)[2]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_1); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_12; + result_12.type_index = kTVMFFINone; + result_12.zero_padding = 0; + result_12.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_12) != 0) { + return -1; + } + } + int32_t condval_2; + if ((mhc_fused_tilelang_comb_mix_strides == NULL)) { + condval_2 = 1; + } else { + condval_2 = ((int32_t)((int64_t*)mhc_fused_tilelang_comb_mix_strides)[1]); + } + if (condval_2 != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_3; + if ((mhc_fused_tilelang_comb_mix_strides == NULL)) { + condval_3 = 1; + } else { + condval_3 = ((int32_t)((int64_t*)mhc_fused_tilelang_comb_mix_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_3); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_13; + result_13.type_index = kTVMFFINone; + result_13.zero_padding = 0; + result_13.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_13) != 0) { + return -1; + } + } + int32_t condval_4; + if ((mhc_fused_tilelang_comb_mix_strides == NULL)) { + condval_4 = 1; + } else { + condval_4 = ((int32_t)((int64_t*)mhc_fused_tilelang_comb_mix_strides)[0]); + } + if ((condval_4 != 16) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_14; + result_14.type_index = kTVMFFINone; + result_14.zero_padding = 0; + result_14.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_14) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)comb_mix)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_15; + result_15.type_index = kTVMFFINone; + result_15.zero_padding = 0; + result_15.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_15) != 0) { + return -1; + } + } + if ((((DLTensor*)comb_mix)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_16; + result_16.type_index = kTVMFFINone; + result_16.zero_padding = 0; + result_16.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_16) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (comb_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_17; + result_17.type_index = kTVMFFINone; + result_17.zero_padding = 0; + result_17.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_17) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)residual_in)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)residual_in)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)residual_in)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual_in"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)residual_in)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual_in)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)residual_in)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_18; + result_18.type_index = kTVMFFINone; + result_18.zero_padding = 0; + result_18.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_18) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_fused_tilelang_comb_mix_shape)[0]) != ((int32_t)((int64_t*)mhc_fused_tilelang_residual_in_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual_in"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_fused_tilelang_residual_in_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_fused_tilelang_comb_mix_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_19; + result_19.type_index = kTVMFFINone; + result_19.zero_padding = 0; + result_19.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_19) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_fused_tilelang_residual_in_shape)[1]) != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual_in"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_fused_tilelang_residual_in_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_20; + result_20.type_index = kTVMFFINone; + result_20.zero_padding = 0; + result_20.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_20) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_fused_tilelang_residual_in_shape)[2]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual_in"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_fused_tilelang_residual_in_shape)[2])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_21; + result_21.type_index = kTVMFFINone; + result_21.zero_padding = 0; + result_21.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_21) != 0) { + return -1; + } + } + int32_t condval_5; + if ((mhc_fused_tilelang_residual_in_strides == NULL)) { + condval_5 = 1; + } else { + condval_5 = ((int32_t)((int64_t*)mhc_fused_tilelang_residual_in_strides)[2]); + } + if (condval_5 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual_in"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_6; + if ((mhc_fused_tilelang_residual_in_strides == NULL)) { + condval_6 = 1; + } else { + condval_6 = ((int32_t)((int64_t*)mhc_fused_tilelang_residual_in_strides)[2]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_6); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_22; + result_22.type_index = kTVMFFINone; + result_22.zero_padding = 0; + result_22.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_22) != 0) { + return -1; + } + } + int32_t condval_7; + if ((mhc_fused_tilelang_residual_in_strides == NULL)) { + condval_7 = 1; + } else { + condval_7 = ((int32_t)((int64_t*)mhc_fused_tilelang_residual_in_strides)[1]); + } + if (condval_7 != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual_in"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_8; + if ((mhc_fused_tilelang_residual_in_strides == NULL)) { + condval_8 = 1; + } else { + condval_8 = ((int32_t)((int64_t*)mhc_fused_tilelang_residual_in_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_8); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_23; + result_23.type_index = kTVMFFINone; + result_23.zero_padding = 0; + result_23.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_23) != 0) { + return -1; + } + } + int32_t condval_9; + if ((mhc_fused_tilelang_residual_in_strides == NULL)) { + condval_9 = 1; + } else { + condval_9 = ((int32_t)((int64_t*)mhc_fused_tilelang_residual_in_strides)[0]); + } + if ((condval_9 != 16384) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual_in"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_24; + result_24.type_index = kTVMFFINone; + result_24.zero_padding = 0; + result_24.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_24) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)residual_in)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual_in"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual_in)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_25; + result_25.type_index = kTVMFFINone; + result_25.zero_padding = 0; + result_25.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_25) != 0) { + return -1; + } + } + if ((((DLTensor*)residual_in)[0].device.device_id) != (((DLTensor*)comb_mix)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual_in"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)residual_in)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_26; + result_26.type_index = kTVMFFINone; + result_26.zero_padding = 0; + result_26.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_26) != 0) { + return -1; + } + } + if ((((DLTensor*)residual_in)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual_in"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual_in)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_27; + result_27.type_index = kTVMFFINone; + result_27.zero_padding = 0; + result_27.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_27) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (residual_in_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual_in"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_28; + result_28.type_index = kTVMFFINone; + result_28.zero_padding = 0; + result_28.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_28) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)post_mix)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)post_mix)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)post_mix)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_29; + result_29.type_index = kTVMFFINone; + result_29.zero_padding = 0; + result_29.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_29) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_fused_tilelang_comb_mix_shape)[0]) != ((int32_t)((int64_t*)mhc_fused_tilelang_post_mix_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_fused_tilelang_post_mix_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_fused_tilelang_comb_mix_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_30; + result_30.type_index = kTVMFFINone; + result_30.zero_padding = 0; + result_30.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_30) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_fused_tilelang_post_mix_shape)[1]) != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_fused_tilelang_post_mix_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_31; + result_31.type_index = kTVMFFINone; + result_31.zero_padding = 0; + result_31.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_31) != 0) { + return -1; + } + } + int32_t condval_10; + if ((mhc_fused_tilelang_post_mix_strides == NULL)) { + condval_10 = 1; + } else { + condval_10 = ((int32_t)((int64_t*)mhc_fused_tilelang_post_mix_strides)[1]); + } + if (condval_10 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_11; + if ((mhc_fused_tilelang_post_mix_strides == NULL)) { + condval_11 = 1; + } else { + condval_11 = ((int32_t)((int64_t*)mhc_fused_tilelang_post_mix_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_11); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_32; + result_32.type_index = kTVMFFINone; + result_32.zero_padding = 0; + result_32.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_32) != 0) { + return -1; + } + } + int32_t condval_12; + if ((mhc_fused_tilelang_post_mix_strides == NULL)) { + condval_12 = 1; + } else { + condval_12 = ((int32_t)((int64_t*)mhc_fused_tilelang_post_mix_strides)[0]); + } + if ((condval_12 != 4) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_33; + result_33.type_index = kTVMFFINone; + result_33.zero_padding = 0; + result_33.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_33) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)post_mix)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_34; + result_34.type_index = kTVMFFINone; + result_34.zero_padding = 0; + result_34.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_34) != 0) { + return -1; + } + } + if ((((DLTensor*)post_mix)[0].device.device_id) != (((DLTensor*)comb_mix)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_35; + result_35.type_index = kTVMFFINone; + result_35.zero_padding = 0; + result_35.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_35) != 0) { + return -1; + } + } + if ((((DLTensor*)post_mix)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_36; + result_36.type_index = kTVMFFINone; + result_36.zero_padding = 0; + result_36.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_36) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (post_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_37; + result_37.type_index = kTVMFFINone; + result_37.zero_padding = 0; + result_37.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_37) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)x_in)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)x_in)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)x_in)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"x_in"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)x_in)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)x_in)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)x_in)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_38; + result_38.type_index = kTVMFFINone; + result_38.zero_padding = 0; + result_38.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_38) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_fused_tilelang_comb_mix_shape)[0]) != ((int32_t)((int64_t*)mhc_fused_tilelang_x_in_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"x_in"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_fused_tilelang_x_in_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_fused_tilelang_comb_mix_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_39; + result_39.type_index = kTVMFFINone; + result_39.zero_padding = 0; + result_39.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_39) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_fused_tilelang_x_in_shape)[1]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"x_in"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_fused_tilelang_x_in_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_40; + result_40.type_index = kTVMFFINone; + result_40.zero_padding = 0; + result_40.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_40) != 0) { + return -1; + } + } + int32_t condval_13; + if ((mhc_fused_tilelang_x_in_strides == NULL)) { + condval_13 = 1; + } else { + condval_13 = ((int32_t)((int64_t*)mhc_fused_tilelang_x_in_strides)[1]); + } + if (condval_13 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"x_in"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_14; + if ((mhc_fused_tilelang_x_in_strides == NULL)) { + condval_14 = 1; + } else { + condval_14 = ((int32_t)((int64_t*)mhc_fused_tilelang_x_in_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_14); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_41; + result_41.type_index = kTVMFFINone; + result_41.zero_padding = 0; + result_41.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_41) != 0) { + return -1; + } + } + int32_t condval_15; + if ((mhc_fused_tilelang_x_in_strides == NULL)) { + condval_15 = 1; + } else { + condval_15 = ((int32_t)((int64_t*)mhc_fused_tilelang_x_in_strides)[0]); + } + if ((condval_15 != 4096) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"x_in"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_42; + result_42.type_index = kTVMFFINone; + result_42.zero_padding = 0; + result_42.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_42) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)x_in)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"x_in"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)x_in)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_43; + result_43.type_index = kTVMFFINone; + result_43.zero_padding = 0; + result_43.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_43) != 0) { + return -1; + } + } + if ((((DLTensor*)x_in)[0].device.device_id) != (((DLTensor*)comb_mix)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"x_in"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)x_in)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_44; + result_44.type_index = kTVMFFINone; + result_44.zero_padding = 0; + result_44.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_44) != 0) { + return -1; + } + } + if ((((DLTensor*)x_in)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"x_in"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)x_in)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_45; + result_45.type_index = kTVMFFINone; + result_45.zero_padding = 0; + result_45.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_45) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (x_in_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"x_in"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_46; + result_46.type_index = kTVMFFINone; + result_46.zero_padding = 0; + result_46.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_46) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)weight_t)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)weight_t)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)weight_t)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"weight_t"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)weight_t)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)weight_t)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)weight_t)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_47; + result_47.type_index = kTVMFFINone; + result_47.zero_padding = 0; + result_47.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_47) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_fused_tilelang_weight_t_shape)[0]) != 24) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"weight_t"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)24; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_fused_tilelang_weight_t_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_48; + result_48.type_index = kTVMFFINone; + result_48.zero_padding = 0; + result_48.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_48) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_fused_tilelang_weight_t_shape)[1]) != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"weight_t"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_fused_tilelang_weight_t_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_49; + result_49.type_index = kTVMFFINone; + result_49.zero_padding = 0; + result_49.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_49) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_fused_tilelang_weight_t_shape)[2]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"weight_t"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_fused_tilelang_weight_t_shape)[2])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_50; + result_50.type_index = kTVMFFINone; + result_50.zero_padding = 0; + result_50.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_50) != 0) { + return -1; + } + } + int32_t condval_16; + if ((mhc_fused_tilelang_weight_t_strides == NULL)) { + condval_16 = 1; + } else { + condval_16 = ((int32_t)((int64_t*)mhc_fused_tilelang_weight_t_strides)[2]); + } + if (condval_16 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"weight_t"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_17; + if ((mhc_fused_tilelang_weight_t_strides == NULL)) { + condval_17 = 1; + } else { + condval_17 = ((int32_t)((int64_t*)mhc_fused_tilelang_weight_t_strides)[2]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_17); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_51; + result_51.type_index = kTVMFFINone; + result_51.zero_padding = 0; + result_51.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_51) != 0) { + return -1; + } + } + int32_t condval_18; + if ((mhc_fused_tilelang_weight_t_strides == NULL)) { + condval_18 = 1; + } else { + condval_18 = ((int32_t)((int64_t*)mhc_fused_tilelang_weight_t_strides)[1]); + } + if (condval_18 != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"weight_t"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_19; + if ((mhc_fused_tilelang_weight_t_strides == NULL)) { + condval_19 = 1; + } else { + condval_19 = ((int32_t)((int64_t*)mhc_fused_tilelang_weight_t_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_19); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_52; + result_52.type_index = kTVMFFINone; + result_52.zero_padding = 0; + result_52.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_52) != 0) { + return -1; + } + } + int32_t condval_20; + if ((mhc_fused_tilelang_weight_t_strides == NULL)) { + condval_20 = 1; + } else { + condval_20 = ((int32_t)((int64_t*)mhc_fused_tilelang_weight_t_strides)[0]); + } + if (condval_20 != 16384) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"weight_t"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)16384; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_21; + if ((mhc_fused_tilelang_weight_t_strides == NULL)) { + condval_21 = 1; + } else { + condval_21 = ((int32_t)((int64_t*)mhc_fused_tilelang_weight_t_strides)[0]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_21); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_53; + result_53.type_index = kTVMFFINone; + result_53.zero_padding = 0; + result_53.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_53) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)weight_t)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"weight_t"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)weight_t)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_54; + result_54.type_index = kTVMFFINone; + result_54.zero_padding = 0; + result_54.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_54) != 0) { + return -1; + } + } + if ((((DLTensor*)weight_t)[0].device.device_id) != (((DLTensor*)comb_mix)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"weight_t"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)weight_t)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_55; + result_55.type_index = kTVMFFINone; + result_55.zero_padding = 0; + result_55.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_55) != 0) { + return -1; + } + } + if ((((DLTensor*)weight_t)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"weight_t"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)weight_t)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_56; + result_56.type_index = kTVMFFINone; + result_56.zero_padding = 0; + result_56.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_56) != 0) { + return -1; + } + } + if (weight_t_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"weight_t"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_57; + result_57.type_index = kTVMFFINone; + result_57.zero_padding = 0; + result_57.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_57) != 0) { + return -1; + } + } + if ((((((DLTensor*)yp_out)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)yp_out)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)yp_out)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"yp_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)yp_out)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)yp_out)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)yp_out)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_58; + result_58.type_index = kTVMFFINone; + result_58.zero_padding = 0; + result_58.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_58) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_fused_tilelang_comb_mix_shape)[0]) != ((int32_t)((int64_t*)mhc_fused_tilelang_yp_out_shape)[1])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"yp_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_fused_tilelang_yp_out_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_fused_tilelang_comb_mix_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_59; + result_59.type_index = kTVMFFINone; + result_59.zero_padding = 0; + result_59.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_59) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_fused_tilelang_yp_out_shape)[2]) != 24) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"yp_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)24; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_fused_tilelang_yp_out_shape)[2])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_60; + result_60.type_index = kTVMFFINone; + result_60.zero_padding = 0; + result_60.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_60) != 0) { + return -1; + } + } + int32_t condval_22; + if ((mhc_fused_tilelang_yp_out_strides == NULL)) { + condval_22 = 1; + } else { + condval_22 = ((int32_t)((int64_t*)mhc_fused_tilelang_yp_out_strides)[2]); + } + if (condval_22 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"yp_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_23; + if ((mhc_fused_tilelang_yp_out_strides == NULL)) { + condval_23 = 1; + } else { + condval_23 = ((int32_t)((int64_t*)mhc_fused_tilelang_yp_out_strides)[2]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_23); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_61; + result_61.type_index = kTVMFFINone; + result_61.zero_padding = 0; + result_61.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_61) != 0) { + return -1; + } + } + int32_t condval_24; + if ((mhc_fused_tilelang_yp_out_strides == NULL)) { + condval_24 = 1; + } else { + condval_24 = ((int32_t)((int64_t*)mhc_fused_tilelang_yp_out_strides)[1]); + } + if ((condval_24 != 24) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"yp_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_62; + result_62.type_index = kTVMFFINone; + result_62.zero_padding = 0; + result_62.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_62) != 0) { + return -1; + } + } + int32_t condval_25; + if ((mhc_fused_tilelang_yp_out_strides == NULL)) { + condval_25 = 1; + } else { + condval_25 = ((int32_t)((int64_t*)mhc_fused_tilelang_yp_out_strides)[0]); + } + if ((((num_tokens * 24) != condval_25) && (num_tokens != 0)) && (split_k != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"yp_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_63; + result_63.type_index = kTVMFFINone; + result_63.zero_padding = 0; + result_63.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_63) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)yp_out)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"yp_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)yp_out)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_64; + result_64.type_index = kTVMFFINone; + result_64.zero_padding = 0; + result_64.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_64) != 0) { + return -1; + } + } + if ((((DLTensor*)yp_out)[0].device.device_id) != (((DLTensor*)comb_mix)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"yp_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)yp_out)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_65; + result_65.type_index = kTVMFFINone; + result_65.zero_padding = 0; + result_65.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_65) != 0) { + return -1; + } + } + if ((((DLTensor*)yp_out)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"yp_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)yp_out)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_66; + result_66.type_index = kTVMFFINone; + result_66.zero_padding = 0; + result_66.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_66) != 0) { + return -1; + } + } + if ((split_k != 0) && (num_tokens != 0)) { + if (yp_out_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"yp_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_67; + result_67.type_index = kTVMFFINone; + result_67.zero_padding = 0; + result_67.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_67) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)rp_out)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)rp_out)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)rp_out)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"rp_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)rp_out)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)rp_out)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)rp_out)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_68; + result_68.type_index = kTVMFFINone; + result_68.zero_padding = 0; + result_68.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_68) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_fused_tilelang_yp_out_shape)[0]) != ((int32_t)((int64_t*)mhc_fused_tilelang_rp_out_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"rp_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_fused_tilelang_rp_out_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_fused_tilelang_yp_out_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_69; + result_69.type_index = kTVMFFINone; + result_69.zero_padding = 0; + result_69.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_69) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_fused_tilelang_comb_mix_shape)[0]) != ((int32_t)((int64_t*)mhc_fused_tilelang_rp_out_shape)[1])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"rp_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_fused_tilelang_rp_out_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_fused_tilelang_comb_mix_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_70; + result_70.type_index = kTVMFFINone; + result_70.zero_padding = 0; + result_70.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_70) != 0) { + return -1; + } + } + int32_t condval_26; + if ((mhc_fused_tilelang_rp_out_strides == NULL)) { + condval_26 = 1; + } else { + condval_26 = ((int32_t)((int64_t*)mhc_fused_tilelang_rp_out_strides)[1]); + } + if ((condval_26 != 1) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"rp_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_71; + result_71.type_index = kTVMFFINone; + result_71.zero_padding = 0; + result_71.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_71) != 0) { + return -1; + } + } + int32_t condval_27; + if ((mhc_fused_tilelang_rp_out_strides == NULL)) { + condval_27 = 1; + } else { + condval_27 = ((int32_t)((int64_t*)mhc_fused_tilelang_rp_out_strides)[0]); + } + if (((((int32_t)((int64_t*)mhc_fused_tilelang_comb_mix_shape)[0]) != condval_27) && (((int32_t)((int64_t*)mhc_fused_tilelang_comb_mix_shape)[0]) != 0)) && (split_k != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"rp_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_72; + result_72.type_index = kTVMFFINone; + result_72.zero_padding = 0; + result_72.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_72) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)rp_out)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"rp_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)rp_out)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_73; + result_73.type_index = kTVMFFINone; + result_73.zero_padding = 0; + result_73.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_73) != 0) { + return -1; + } + } + if ((((DLTensor*)rp_out)[0].device.device_id) != (((DLTensor*)comb_mix)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"rp_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)rp_out)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_74; + result_74.type_index = kTVMFFINone; + result_74.zero_padding = 0; + result_74.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_74) != 0) { + return -1; + } + } + if ((((DLTensor*)rp_out)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"rp_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)rp_out)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_75; + result_75.type_index = kTVMFFINone; + result_75.zero_padding = 0; + result_75.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_75) != 0) { + return -1; + } + } + if ((split_k != 0) && (num_tokens != 0)) { + if (rp_out_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"rp_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_76; + result_76.type_index = kTVMFFINone; + result_76.zero_padding = 0; + result_76.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_76) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)residual_out)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)residual_out)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)residual_out)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)residual_out)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual_out)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)residual_out)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_77; + result_77.type_index = kTVMFFINone; + result_77.zero_padding = 0; + result_77.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_77) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_fused_tilelang_comb_mix_shape)[0]) != ((int32_t)((int64_t*)mhc_fused_tilelang_residual_out_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_fused_tilelang_residual_out_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_fused_tilelang_comb_mix_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_78; + result_78.type_index = kTVMFFINone; + result_78.zero_padding = 0; + result_78.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_78) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_fused_tilelang_residual_out_shape)[1]) != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_fused_tilelang_residual_out_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_79; + result_79.type_index = kTVMFFINone; + result_79.zero_padding = 0; + result_79.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_79) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_fused_tilelang_residual_out_shape)[2]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_fused_tilelang_residual_out_shape)[2])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_80; + result_80.type_index = kTVMFFINone; + result_80.zero_padding = 0; + result_80.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_80) != 0) { + return -1; + } + } + int32_t condval_28; + if ((mhc_fused_tilelang_residual_out_strides == NULL)) { + condval_28 = 1; + } else { + condval_28 = ((int32_t)((int64_t*)mhc_fused_tilelang_residual_out_strides)[2]); + } + if (condval_28 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_29; + if ((mhc_fused_tilelang_residual_out_strides == NULL)) { + condval_29 = 1; + } else { + condval_29 = ((int32_t)((int64_t*)mhc_fused_tilelang_residual_out_strides)[2]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_29); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_81; + result_81.type_index = kTVMFFINone; + result_81.zero_padding = 0; + result_81.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_81) != 0) { + return -1; + } + } + int32_t condval_30; + if ((mhc_fused_tilelang_residual_out_strides == NULL)) { + condval_30 = 1; + } else { + condval_30 = ((int32_t)((int64_t*)mhc_fused_tilelang_residual_out_strides)[1]); + } + if (condval_30 != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_31; + if ((mhc_fused_tilelang_residual_out_strides == NULL)) { + condval_31 = 1; + } else { + condval_31 = ((int32_t)((int64_t*)mhc_fused_tilelang_residual_out_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_31); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_82; + result_82.type_index = kTVMFFINone; + result_82.zero_padding = 0; + result_82.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_82) != 0) { + return -1; + } + } + int32_t condval_32; + if ((mhc_fused_tilelang_residual_out_strides == NULL)) { + condval_32 = 1; + } else { + condval_32 = ((int32_t)((int64_t*)mhc_fused_tilelang_residual_out_strides)[0]); + } + if ((condval_32 != 16384) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_83; + result_83.type_index = kTVMFFINone; + result_83.zero_padding = 0; + result_83.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_83) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)residual_out)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual_out)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_84; + result_84.type_index = kTVMFFINone; + result_84.zero_padding = 0; + result_84.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_84) != 0) { + return -1; + } + } + if ((((DLTensor*)residual_out)[0].device.device_id) != (((DLTensor*)comb_mix)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)residual_out)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_85; + result_85.type_index = kTVMFFINone; + result_85.zero_padding = 0; + result_85.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_85) != 0) { + return -1; + } + } + if ((((DLTensor*)residual_out)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual_out)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_86; + result_86.type_index = kTVMFFINone; + result_86.zero_padding = 0; + result_86.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_86) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (residual_out_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_fused_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual_out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_87; + result_87.type_index = kTVMFFINone; + result_87.zero_padding = 0; + result_87.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_87) != 0) { + return -1; + } + } + } else { + } + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = ((int64_t)2); + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = ((int64_t)dev_id); + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + if (__tvm_set_device_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_set_device", &__tvm_set_device_packed) != 0) { + return -1; + } + } + TVMFFIAny result_88; + result_88.type_index = kTVMFFINone; + result_88.zero_padding = 0; + result_88.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_set_device_packed, (TVMFFIAny*) stack_ffi_any, 2, &result_88) != 0) { + return -1; + } + if (comb_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = comb_mix_1; + if (post_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = post_mix_1; + if (residual_in_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = residual_in_1; + if (residual_out_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_ptr) = residual_out_1; + if (rp_out_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_ptr) = rp_out_1; + if (weight_t_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_ptr) = weight_t_1; + if (x_in_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_ptr) = x_in_1; + if (yp_out_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_ptr) = yp_out_1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = ((int64_t)num_tokens); + (((TVMFFIAny*)stack_ffi_any)[9].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[9].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[9].v_int64) = ((int64_t)split_k); + (((TVMFFIAny*)stack_ffi_any)[10].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[10].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[10].v_int64) = ((int64_t)num_tokens); + (((TVMFFIAny*)stack_ffi_any)[11].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[11].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[11].v_int64) = ((int64_t)12); + (((TVMFFIAny*)stack_ffi_any)[12].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[12].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[12].v_int64) = ((int64_t)split_k); + (((TVMFFIAny*)stack_ffi_any)[13].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[13].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[13].v_int64) = ((int64_t)256); + (((TVMFFIAny*)stack_ffi_any)[14].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[14].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[14].v_int64) = ((int64_t)1); + (((TVMFFIAny*)stack_ffi_any)[15].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[15].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[15].v_int64) = ((int64_t)1); + (((TVMFFIAny*)stack_ffi_any)[16].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[16].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[16].v_int64) = ((int64_t)176); + (((TVMFFIAny*)stack_ffi_any)[17].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[17].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[17].v_int64) = (int64_t)0; + if (mhc_fused_tilelang_kernel_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "mhc_fused_tilelang_kernel", &mhc_fused_tilelang_kernel_packed) != 0) { + return -1; + } + } + TVMFFIAny result_89; + result_89.type_index = kTVMFFINone; + result_89.zero_padding = 0; + result_89.v_int64 = 0; + if (TVMFFIFunctionCall(mhc_fused_tilelang_kernel_packed, (TVMFFIAny*) stack_ffi_any, 17, &result_89) != 0) { + return -1; + } + return 0; +} + +// CodegenC: NOTE: Auto-generated entry function +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_main(void* self, void* args,int num_args, void* result) { + return __tvm_ffi_mhc_fused_tilelang(self, args, num_args, result); +} diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/96e9b9b5cf258ab70fb96c06c4ba12fa70819bfb1b8c147e903abf420053524b/params.pkl b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/96e9b9b5cf258ab70fb96c06c4ba12fa70819bfb1b8c147e903abf420053524b/params.pkl new file mode 100644 index 0000000..2a45bcd Binary files /dev/null and b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/96e9b9b5cf258ab70fb96c06c4ba12fa70819bfb1b8c147e903abf420053524b/params.pkl differ diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/bc130d0880c8dc66c0a86cfbe52a5accea0d7723ef84286eda1809080514e34c/device_kernel.cu b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/bc130d0880c8dc66c0a86cfbe52a5accea0d7723ef84286eda1809080514e34c/device_kernel.cu new file mode 100644 index 0000000..7921ace --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/bc130d0880c8dc66c0a86cfbe52a5accea0d7723ef84286eda1809080514e34c/device_kernel.cu @@ -0,0 +1,190 @@ +#include +#include +#include +#include +#include +#include +#ifdef ENABLE_BF16 +#include +#endif + +extern "C" __global__ void hc_head_fuse_tilelang_kernel(const float* fn, const float* hc_base, const float* hc_scale, bfloat16_t* out, const bfloat16_t* residual, int num_tokens); +extern "C" __global__ void __launch_bounds__(128, 1) hc_head_fuse_tilelang_kernel(const float* fn, const float* hc_base, const float* hc_scale, bfloat16_t* out, const bfloat16_t* residual, int num_tokens) { + extern __shared__ __align__(1024) uchar buf_dyn_shmem[]; + float sqrsum_r[1]; + float mixes_r[4]; + bfloat16_t residual_local_cast[8]; + float x_local[8]; + float fn_local[8]; + float rsqrt_val[1]; + float xl[32]; + float ol[8]; + bfloat16_t xs_local_cast_1[8]; + bfloat16_t out_local_cast_2[8]; + bfloat16_t xs_local_cast_3[8]; + bfloat16_t out_local_cast_4[8]; + bfloat16_t xs_local_cast_5[8]; + bfloat16_t out_local_cast_6[8]; + cudaGridDependencySynchronize(); + sqrsum_r[0] = 0x0p+0f/*0.000000e+00*/; + float broadcast_var = 0x0p+0f/*0.000000e+00*/; + *(float4*)(mixes_r + 0) = make_float4(broadcast_var, broadcast_var, broadcast_var, broadcast_var); + for (int m_c = 0; m_c < 4; ++m_c) { + for (int i_h = 0; i_h < 4; ++i_h) { + *(uint4*)(residual_local_cast + 0) = *(uint4*)(residual + ((((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + (((int64_t)m_c) * (int64_t)4096)) + (((int64_t)i_h) * (int64_t)1024)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8))); + for (int i = 0; i < 2; ++i) { + float4 __1; + uint2 v_ = *(uint2*)(residual_local_cast + (i * 4)); + ((float2*)(&__1))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v_))[0]); + ((float2*)(&__1))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v_))[1]); + *(float4*)(x_local + (i * 4)) = __1; + } + #pragma unroll + for (int i_1 = 0; i_1 < 8; ++i_1) { + sqrsum_r[0] = (sqrsum_r[0] + (x_local[i_1] * x_local[i_1])); + } + #pragma unroll + for (int m_m = 0; m_m < 4; ++m_m) { + #pragma unroll + for (int i_2 = 0; i_2 < 2; ++i_2) { + *(float4*)(fn_local + (i_2 * 4)) = *(float4*)(fn + (((((m_m * 16384) + (m_c * 4096)) + (i_h * 1024)) + (((int)threadIdx.x) * 8)) + (i_2 * 4))); + } + #pragma unroll + for (int i_3 = 0; i_3 < 8; ++i_3) { + mixes_r[m_m] = (mixes_r[m_m] + (x_local[i_3] * fn_local[i_3])); + } + } + } + } + sqrsum_r[0] = tl::AllReduce>::run(sqrsum_r[0], (&(((float*)buf_dyn_shmem)[0]))); + __syncthreads(); + for (int __finred_0 = 0; __finred_0 < 4; ++__finred_0) { + mixes_r[__finred_0] = tl::AllReduce>::run(mixes_r[__finred_0], (&(((float*)buf_dyn_shmem)[0]))); + } + rsqrt_val[0] = rsqrtf(((sqrsum_r[0] / 0x1p+14f/*1.638400e+04*/) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + __syncthreads(); + if ((((int)threadIdx.x) >> 2) == 0) { + ((float*)buf_dyn_shmem)[(((int)threadIdx.x) & 3)] = ((0x1p+0f/*1.000000e+00*/ / (0x1p+0f/*1.000000e+00*/ + expf((0x0p+0f/*0.000000e+00*/ - (((mixes_r[(((int)threadIdx.x) & 3)] * rsqrt_val[0]) * hc_scale[0]) + hc_base[(((int)threadIdx.x) & 3)]))))) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/); + } + __syncthreads(); + #pragma unroll + for (int i_4 = 0; i_4 < 4; ++i_4) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[(((i_4 * 1024) + (((int)threadIdx.x) * 8)) + 256)])), (&(residual[(((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + (((int64_t)i_4) * (int64_t)4096)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8))]))); + } + tl::cp_async_commit(); + #pragma unroll + for (int i_5 = 0; i_5 < 4; ++i_5) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[(((i_5 * 1024) + (((int)threadIdx.x) * 8)) + 4352)])), (&(residual[((((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + (((int64_t)i_5) * (int64_t)4096)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8)) + (int64_t)1024)]))); + } + tl::cp_async_commit(); + for (int i0_h = 0; i0_h < 2; ++i0_h) { + tl::cp_async_wait<1>(); + __syncthreads(); + #pragma unroll + for (int i_6 = 0; i_6 < 4; ++i_6) { + *(uint4*)(xs_local_cast_1 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + ((((i0_h * 4096) + (i_6 * 1024)) + (((int)threadIdx.x) * 8)) + 256)); + for (int vec = 0; vec < 2; ++vec) { + float4 __2; + uint2 v__1 = *(uint2*)(xs_local_cast_1 + (vec * 4)); + ((float2*)(&__2))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__1))[0]); + ((float2*)(&__2))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__1))[1]); + *(float4*)(xl + ((i_6 * 8) + (vec * 4))) = __2; + } + } + __syncthreads(); + #pragma unroll + for (int i_7 = 0; i_7 < 4; ++i_7) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i0_h * 4096) + (i_7 * 1024)) + (((int)threadIdx.x) * 8)) + 256)])), (&(residual[(((((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + (((int64_t)i_7) * (int64_t)4096)) + (((int64_t)i0_h) * (int64_t)1024)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8)) + (int64_t)2048)]))); + } + tl::cp_async_commit(); + #pragma unroll + for (int i_8 = 0; i_8 < 2; ++i_8) { + float broadcast_var_1 = 0x0p+0f/*0.000000e+00*/; + *(float4*)(ol + (i_8 * 4)) = make_float4(broadcast_var_1, broadcast_var_1, broadcast_var_1, broadcast_var_1); + } + __syncthreads(); + for (int i_hc = 0; i_hc < 4; ++i_hc) { + float pre = ((float*)buf_dyn_shmem)[i_hc]; + #pragma unroll + for (int i_9 = 0; i_9 < 8; ++i_9) { + ol[i_9] = (ol[i_9] + (pre * xl[((i_hc * 8) + i_9)])); + } + } + for (int i_10 = 0; i_10 < 2; ++i_10) { + uint2 __3; + float4 v__2 = *(float4*)(ol + (i_10 * 4)); + (reinterpret_cast<__nv_bfloat162*>(&__3))[0] = __float22bfloat162_rn(((float2*)(&v__2))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__3))[1] = __float22bfloat162_rn(((float2*)(&v__2))[1]); + *(uint2*)(out_local_cast_2 + (i_10 * 4)) = __3; + } + *(uint4*)(out + (((((int64_t)((int)blockIdx.x)) * (int64_t)4096) + (((int64_t)i0_h) * (int64_t)1024)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8))) = *(uint4*)(out_local_cast_2 + 0); + } + tl::cp_async_wait<1>(); + __syncthreads(); + #pragma unroll + for (int i_11 = 0; i_11 < 4; ++i_11) { + *(uint4*)(xs_local_cast_3 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_11 * 1024) + (((int)threadIdx.x) * 8)) + 256)); + for (int vec_1 = 0; vec_1 < 2; ++vec_1) { + float4 __4; + uint2 v__3 = *(uint2*)(xs_local_cast_3 + (vec_1 * 4)); + ((float2*)(&__4))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__3))[0]); + ((float2*)(&__4))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__3))[1]); + *(float4*)(xl + ((i_11 * 8) + (vec_1 * 4))) = __4; + } + } + #pragma unroll + for (int i_12 = 0; i_12 < 2; ++i_12) { + float broadcast_var_2 = 0x0p+0f/*0.000000e+00*/; + *(float4*)(ol + (i_12 * 4)) = make_float4(broadcast_var_2, broadcast_var_2, broadcast_var_2, broadcast_var_2); + } + for (int i_hc_1 = 0; i_hc_1 < 4; ++i_hc_1) { + float pre_1 = ((float*)buf_dyn_shmem)[i_hc_1]; + #pragma unroll + for (int i_13 = 0; i_13 < 8; ++i_13) { + ol[i_13] = (ol[i_13] + (pre_1 * xl[((i_hc_1 * 8) + i_13)])); + } + } + for (int i_14 = 0; i_14 < 2; ++i_14) { + uint2 __5; + float4 v__4 = *(float4*)(ol + (i_14 * 4)); + (reinterpret_cast<__nv_bfloat162*>(&__5))[0] = __float22bfloat162_rn(((float2*)(&v__4))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__5))[1] = __float22bfloat162_rn(((float2*)(&v__4))[1]); + *(uint2*)(out_local_cast_4 + (i_14 * 4)) = __5; + } + *(uint4*)(out + (((((int64_t)((int)blockIdx.x)) * (int64_t)4096) + (((int64_t)((int)threadIdx.x)) * (int64_t)8)) + (int64_t)2048)) = *(uint4*)(out_local_cast_4 + 0); + tl::cp_async_wait<0>(); + __syncthreads(); + #pragma unroll + for (int i_15 = 0; i_15 < 4; ++i_15) { + *(uint4*)(xs_local_cast_5 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_15 * 1024) + (((int)threadIdx.x) * 8)) + 4352)); + for (int vec_2 = 0; vec_2 < 2; ++vec_2) { + float4 __6; + uint2 v__5 = *(uint2*)(xs_local_cast_5 + (vec_2 * 4)); + ((float2*)(&__6))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__5))[0]); + ((float2*)(&__6))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__5))[1]); + *(float4*)(xl + ((i_15 * 8) + (vec_2 * 4))) = __6; + } + } + #pragma unroll + for (int i_16 = 0; i_16 < 2; ++i_16) { + float broadcast_var_3 = 0x0p+0f/*0.000000e+00*/; + *(float4*)(ol + (i_16 * 4)) = make_float4(broadcast_var_3, broadcast_var_3, broadcast_var_3, broadcast_var_3); + } + for (int i_hc_2 = 0; i_hc_2 < 4; ++i_hc_2) { + float pre_2 = ((float*)buf_dyn_shmem)[i_hc_2]; + #pragma unroll + for (int i_17 = 0; i_17 < 8; ++i_17) { + ol[i_17] = (ol[i_17] + (pre_2 * xl[((i_hc_2 * 8) + i_17)])); + } + } + for (int i_18 = 0; i_18 < 2; ++i_18) { + uint2 __7; + float4 v__6 = *(float4*)(ol + (i_18 * 4)); + (reinterpret_cast<__nv_bfloat162*>(&__7))[0] = __float22bfloat162_rn(((float2*)(&v__6))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__7))[1] = __float22bfloat162_rn(((float2*)(&v__6))[1]); + *(uint2*)(out_local_cast_6 + (i_18 * 4)) = __7; + } + *(uint4*)(out + (((((int64_t)((int)blockIdx.x)) * (int64_t)4096) + (((int64_t)((int)threadIdx.x)) * (int64_t)8)) + (int64_t)3072)) = *(uint4*)(out_local_cast_6 + 0); + cudaTriggerProgrammaticLaunchCompletion(); +} + diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/bc130d0880c8dc66c0a86cfbe52a5accea0d7723ef84286eda1809080514e34c/host_kernel.cu b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/bc130d0880c8dc66c0a86cfbe52a5accea0d7723ef84286eda1809080514e34c/host_kernel.cu new file mode 100644 index 0000000..4ceadb9 --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/bc130d0880c8dc66c0a86cfbe52a5accea0d7723ef84286eda1809080514e34c/host_kernel.cu @@ -0,0 +1,1828 @@ +// tilelang target: c -keys=cpu +#define TVM_EXPORTS +#include "tvm/runtime/base.h" +#include "tvm/runtime/c_backend_api.h" +#include "tvm/ffi/c_api.h" +#include +#include +#include +#ifdef __OBJC__ +#include "tvm/runtime/device_api.h" +#include "tvm/ffi/function.h" +#include +#include +#include +#endif +void* __tvm_ffi__library_ctx = NULL; +static void* __tvm_error_ndim_mismatch_packed = NULL; +static void* __tvm_error_dtype_mismatch_packed = NULL; +static void* __tvm_error_expect_eq_packed = NULL; +static void* __tvm_error_constraint_violation_packed = NULL; +static void* __tvm_error_byte_offset_mismatch_packed = NULL; +static void* __tvm_error_device_type_mismatch_packed = NULL; +static void* __tvm_error_null_ptr_packed = NULL; +static void* __tvm_set_device_packed = NULL; +static void* hc_head_fuse_tilelang_kernel_packed = NULL; +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_hc_head_fuse_tilelang(void* self_handle, void* args, int32_t num_args, void* result); +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_hc_head_fuse_tilelang(void* self_handle, void* args, int32_t num_args, void* result) { + __attribute__((aligned(64))) TVMFFIAny stack[12]; + void* stack_ffi_any = stack; + if (!((num_args == 5))) { + char __tvm_assert_msg_buf[512]; + snprintf(__tvm_assert_msg_buf, 512, "%s; expected: %lld, got: %lld", "hc_head_fuse_tilelang: num_args should be 5", (long long)(num_args), (long long)(5)); + TVMFFIErrorSetRaisedFromCStr("RuntimeError", __tvm_assert_msg_buf); + return -1; + } + if (!(!(args == NULL))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "hc_head_fuse_tilelang: args pointer is NULL"); + return -1; + } + int32_t residual_type_index = (((TVMFFIAny*)args)[0].type_index); + if (!(((((residual_type_index == 0) || (residual_type_index == 4)) || (residual_type_index == 7)) || (64 <= residual_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel hc_head_fuse_tilelang input residual expected pointer or tensor handle"); + return -1; + } + int32_t fn_type_index = (((TVMFFIAny*)args)[1].type_index); + if (!(((((fn_type_index == 0) || (fn_type_index == 4)) || (fn_type_index == 7)) || (64 <= fn_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel hc_head_fuse_tilelang input fn expected pointer or tensor handle"); + return -1; + } + int32_t hc_scale_type_index = (((TVMFFIAny*)args)[2].type_index); + if (!(((((hc_scale_type_index == 0) || (hc_scale_type_index == 4)) || (hc_scale_type_index == 7)) || (64 <= hc_scale_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel hc_head_fuse_tilelang input hc_scale expected pointer or tensor handle"); + return -1; + } + int32_t hc_base_type_index = (((TVMFFIAny*)args)[3].type_index); + if (!(((((hc_base_type_index == 0) || (hc_base_type_index == 4)) || (hc_base_type_index == 7)) || (64 <= hc_base_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel hc_head_fuse_tilelang input hc_base expected pointer or tensor handle"); + return -1; + } + int32_t out_type_index = (((TVMFFIAny*)args)[4].type_index); + if (!(((((out_type_index == 0) || (out_type_index == 4)) || (out_type_index == 7)) || (64 <= out_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel hc_head_fuse_tilelang input out expected pointer or tensor handle"); + return -1; + } + void* residual = ((residual_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[0].v_ptr) + 24)) : (((TVMFFIAny*)args)[0].v_ptr)); + void* fn = ((fn_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[1].v_ptr) + 24)) : (((TVMFFIAny*)args)[1].v_ptr)); + void* hc_scale = ((hc_scale_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[2].v_ptr) + 24)) : (((TVMFFIAny*)args)[2].v_ptr)); + void* hc_base = ((hc_base_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[3].v_ptr) + 24)) : (((TVMFFIAny*)args)[3].v_ptr)); + void* out = ((out_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[4].v_ptr) + 24)) : (((TVMFFIAny*)args)[4].v_ptr)); + bool hc_head_fuse_tilelang_residual_is_null = (residual == NULL); + if (!(!hc_head_fuse_tilelang_residual_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "hc_head_fuse_tilelang.residual is expected to have non-NULL pointer"); + return -1; + } + bool hc_head_fuse_tilelang_fn_is_null = (fn == NULL); + if (!(!hc_head_fuse_tilelang_fn_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "hc_head_fuse_tilelang.fn is expected to have non-NULL pointer"); + return -1; + } + bool hc_head_fuse_tilelang_hc_scale_is_null = (hc_scale == NULL); + if (!(!hc_head_fuse_tilelang_hc_scale_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "hc_head_fuse_tilelang.hc_scale is expected to have non-NULL pointer"); + return -1; + } + bool hc_head_fuse_tilelang_hc_base_is_null = (hc_base == NULL); + if (!(!hc_head_fuse_tilelang_hc_base_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "hc_head_fuse_tilelang.hc_base is expected to have non-NULL pointer"); + return -1; + } + bool hc_head_fuse_tilelang_out_is_null = (out == NULL); + if (!(!hc_head_fuse_tilelang_out_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "hc_head_fuse_tilelang.out is expected to have non-NULL pointer"); + return -1; + } + void* hc_head_fuse_tilelang_residual_shape = (((DLTensor*)residual)[0].shape); + void* hc_head_fuse_tilelang_fn_shape = (((DLTensor*)fn)[0].shape); + void* hc_head_fuse_tilelang_hc_scale_shape = (((DLTensor*)hc_scale)[0].shape); + void* hc_head_fuse_tilelang_hc_base_shape = (((DLTensor*)hc_base)[0].shape); + void* hc_head_fuse_tilelang_out_shape = (((DLTensor*)out)[0].shape); + if ((((DLTensor*)residual)[0].ndim) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"hc_head_fuse_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_1; + result_1.type_index = kTVMFFINone; + result_1.zero_padding = 0; + result_1.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_1) != 0) { + return -1; + } + } + if (!((bool)1)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "Symbolic shape variable num_tokens requires at least one non-null buffer among: hc_head_fuse_tilelang.residual, hc_head_fuse_tilelang.out"); + return -1; + } + int32_t num_tokens = ((int32_t)((int64_t*)hc_head_fuse_tilelang_residual_shape)[0]); + void* hc_head_fuse_tilelang_residual_strides = (((DLTensor*)residual)[0].strides); + int32_t dev_id = (((DLTensor*)residual)[0].device.device_id); + void* residual_1 = (((DLTensor*)residual)[0].data); + if ((((DLTensor*)fn)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"hc_head_fuse_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"fn"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)fn)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_2; + result_2.type_index = kTVMFFINone; + result_2.zero_padding = 0; + result_2.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_2) != 0) { + return -1; + } + } + void* hc_head_fuse_tilelang_fn_strides = (((DLTensor*)fn)[0].strides); + void* fn_1 = (((DLTensor*)fn)[0].data); + if ((((DLTensor*)hc_scale)[0].ndim) != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"hc_head_fuse_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_3; + result_3.type_index = kTVMFFINone; + result_3.zero_padding = 0; + result_3.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_3) != 0) { + return -1; + } + } + void* hc_head_fuse_tilelang_hc_scale_strides = (((DLTensor*)hc_scale)[0].strides); + void* hc_scale_1 = (((DLTensor*)hc_scale)[0].data); + if ((((DLTensor*)hc_base)[0].ndim) != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"hc_head_fuse_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_4; + result_4.type_index = kTVMFFINone; + result_4.zero_padding = 0; + result_4.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_4) != 0) { + return -1; + } + } + void* hc_head_fuse_tilelang_hc_base_strides = (((DLTensor*)hc_base)[0].strides); + void* hc_base_1 = (((DLTensor*)hc_base)[0].data); + if ((((DLTensor*)out)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"hc_head_fuse_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)out)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_5; + result_5.type_index = kTVMFFINone; + result_5.zero_padding = 0; + result_5.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_5) != 0) { + return -1; + } + } + void* hc_head_fuse_tilelang_out_strides = (((DLTensor*)out)[0].strides); + void* out_1 = (((DLTensor*)out)[0].data); + if ((((((DLTensor*)residual)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)residual)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)residual)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"hc_head_fuse_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)residual)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)residual)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_6; + result_6.type_index = kTVMFFINone; + result_6.zero_padding = 0; + result_6.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_6) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)hc_head_fuse_tilelang_residual_shape)[1]) != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"hc_head_fuse_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)hc_head_fuse_tilelang_residual_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_7; + result_7.type_index = kTVMFFINone; + result_7.zero_padding = 0; + result_7.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_7) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)hc_head_fuse_tilelang_residual_shape)[2]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"hc_head_fuse_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)hc_head_fuse_tilelang_residual_shape)[2])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_8; + result_8.type_index = kTVMFFINone; + result_8.zero_padding = 0; + result_8.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_8) != 0) { + return -1; + } + } + int32_t condval; + if ((hc_head_fuse_tilelang_residual_strides == NULL)) { + condval = 1; + } else { + condval = ((int32_t)((int64_t*)hc_head_fuse_tilelang_residual_strides)[2]); + } + if (condval != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"hc_head_fuse_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_1; + if ((hc_head_fuse_tilelang_residual_strides == NULL)) { + condval_1 = 1; + } else { + condval_1 = ((int32_t)((int64_t*)hc_head_fuse_tilelang_residual_strides)[2]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_1); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_9; + result_9.type_index = kTVMFFINone; + result_9.zero_padding = 0; + result_9.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_9) != 0) { + return -1; + } + } + int32_t condval_2; + if ((hc_head_fuse_tilelang_residual_strides == NULL)) { + condval_2 = 1; + } else { + condval_2 = ((int32_t)((int64_t*)hc_head_fuse_tilelang_residual_strides)[1]); + } + if (condval_2 != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"hc_head_fuse_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_3; + if ((hc_head_fuse_tilelang_residual_strides == NULL)) { + condval_3 = 1; + } else { + condval_3 = ((int32_t)((int64_t*)hc_head_fuse_tilelang_residual_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_3); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_10; + result_10.type_index = kTVMFFINone; + result_10.zero_padding = 0; + result_10.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_10) != 0) { + return -1; + } + } + int32_t condval_4; + if ((hc_head_fuse_tilelang_residual_strides == NULL)) { + condval_4 = 1; + } else { + condval_4 = ((int32_t)((int64_t*)hc_head_fuse_tilelang_residual_strides)[0]); + } + if ((condval_4 != 16384) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"hc_head_fuse_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_11; + result_11.type_index = kTVMFFINone; + result_11.zero_padding = 0; + result_11.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_11) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)residual)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"hc_head_fuse_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_12; + result_12.type_index = kTVMFFINone; + result_12.zero_padding = 0; + result_12.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_12) != 0) { + return -1; + } + } + if ((((DLTensor*)residual)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"hc_head_fuse_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_13; + result_13.type_index = kTVMFFINone; + result_13.zero_padding = 0; + result_13.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_13) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (residual_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"hc_head_fuse_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_14; + result_14.type_index = kTVMFFINone; + result_14.zero_padding = 0; + result_14.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_14) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)fn)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)fn)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)fn)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"hc_head_fuse_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"fn"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)fn)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)fn)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)fn)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_15; + result_15.type_index = kTVMFFINone; + result_15.zero_padding = 0; + result_15.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_15) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)hc_head_fuse_tilelang_fn_shape)[0]) != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"hc_head_fuse_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"fn"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)hc_head_fuse_tilelang_fn_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_16; + result_16.type_index = kTVMFFINone; + result_16.zero_padding = 0; + result_16.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_16) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)hc_head_fuse_tilelang_fn_shape)[1]) != 16384) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"hc_head_fuse_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"fn"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)16384; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)hc_head_fuse_tilelang_fn_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_17; + result_17.type_index = kTVMFFINone; + result_17.zero_padding = 0; + result_17.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_17) != 0) { + return -1; + } + } + int32_t condval_5; + if ((hc_head_fuse_tilelang_fn_strides == NULL)) { + condval_5 = 1; + } else { + condval_5 = ((int32_t)((int64_t*)hc_head_fuse_tilelang_fn_strides)[1]); + } + if (condval_5 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"hc_head_fuse_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"fn"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_6; + if ((hc_head_fuse_tilelang_fn_strides == NULL)) { + condval_6 = 1; + } else { + condval_6 = ((int32_t)((int64_t*)hc_head_fuse_tilelang_fn_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_6); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_18; + result_18.type_index = kTVMFFINone; + result_18.zero_padding = 0; + result_18.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_18) != 0) { + return -1; + } + } + int32_t condval_7; + if ((hc_head_fuse_tilelang_fn_strides == NULL)) { + condval_7 = 1; + } else { + condval_7 = ((int32_t)((int64_t*)hc_head_fuse_tilelang_fn_strides)[0]); + } + if (condval_7 != 16384) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"hc_head_fuse_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"fn"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)16384; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_8; + if ((hc_head_fuse_tilelang_fn_strides == NULL)) { + condval_8 = 1; + } else { + condval_8 = ((int32_t)((int64_t*)hc_head_fuse_tilelang_fn_strides)[0]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_8); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_19; + result_19.type_index = kTVMFFINone; + result_19.zero_padding = 0; + result_19.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_19) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)fn)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"hc_head_fuse_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"fn"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)fn)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_20; + result_20.type_index = kTVMFFINone; + result_20.zero_padding = 0; + result_20.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_20) != 0) { + return -1; + } + } + if ((((DLTensor*)fn)[0].device.device_id) != (((DLTensor*)residual)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"hc_head_fuse_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"fn"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)fn)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_21; + result_21.type_index = kTVMFFINone; + result_21.zero_padding = 0; + result_21.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_21) != 0) { + return -1; + } + } + if ((((DLTensor*)fn)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"hc_head_fuse_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"fn"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)fn)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_22; + result_22.type_index = kTVMFFINone; + result_22.zero_padding = 0; + result_22.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_22) != 0) { + return -1; + } + } + if (fn_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"hc_head_fuse_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"fn"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_23; + result_23.type_index = kTVMFFINone; + result_23.zero_padding = 0; + result_23.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_23) != 0) { + return -1; + } + } + if ((((((DLTensor*)hc_scale)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)hc_scale)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)hc_scale)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"hc_head_fuse_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_24; + result_24.type_index = kTVMFFINone; + result_24.zero_padding = 0; + result_24.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_24) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)hc_head_fuse_tilelang_hc_scale_shape)[0]) != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"hc_head_fuse_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)hc_head_fuse_tilelang_hc_scale_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_25; + result_25.type_index = kTVMFFINone; + result_25.zero_padding = 0; + result_25.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_25) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)hc_scale)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"hc_head_fuse_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_26; + result_26.type_index = kTVMFFINone; + result_26.zero_padding = 0; + result_26.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_26) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_scale)[0].device.device_id) != (((DLTensor*)residual)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"hc_head_fuse_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_27; + result_27.type_index = kTVMFFINone; + result_27.zero_padding = 0; + result_27.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_27) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_scale)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"hc_head_fuse_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_28; + result_28.type_index = kTVMFFINone; + result_28.zero_padding = 0; + result_28.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_28) != 0) { + return -1; + } + } + if (hc_scale_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"hc_head_fuse_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_29; + result_29.type_index = kTVMFFINone; + result_29.zero_padding = 0; + result_29.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_29) != 0) { + return -1; + } + } + if ((((((DLTensor*)hc_base)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)hc_base)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)hc_base)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"hc_head_fuse_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_30; + result_30.type_index = kTVMFFINone; + result_30.zero_padding = 0; + result_30.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_30) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)hc_head_fuse_tilelang_hc_base_shape)[0]) != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"hc_head_fuse_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)hc_head_fuse_tilelang_hc_base_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_31; + result_31.type_index = kTVMFFINone; + result_31.zero_padding = 0; + result_31.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_31) != 0) { + return -1; + } + } + int32_t condval_9; + if ((hc_head_fuse_tilelang_hc_base_strides == NULL)) { + condval_9 = 1; + } else { + condval_9 = ((int32_t)((int64_t*)hc_head_fuse_tilelang_hc_base_strides)[0]); + } + if (condval_9 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"hc_head_fuse_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_10; + if ((hc_head_fuse_tilelang_hc_base_strides == NULL)) { + condval_10 = 1; + } else { + condval_10 = ((int32_t)((int64_t*)hc_head_fuse_tilelang_hc_base_strides)[0]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_10); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_32; + result_32.type_index = kTVMFFINone; + result_32.zero_padding = 0; + result_32.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_32) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)hc_base)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"hc_head_fuse_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_33; + result_33.type_index = kTVMFFINone; + result_33.zero_padding = 0; + result_33.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_33) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_base)[0].device.device_id) != (((DLTensor*)residual)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"hc_head_fuse_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_34; + result_34.type_index = kTVMFFINone; + result_34.zero_padding = 0; + result_34.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_34) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_base)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"hc_head_fuse_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_35; + result_35.type_index = kTVMFFINone; + result_35.zero_padding = 0; + result_35.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_35) != 0) { + return -1; + } + } + if (hc_base_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"hc_head_fuse_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_36; + result_36.type_index = kTVMFFINone; + result_36.zero_padding = 0; + result_36.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_36) != 0) { + return -1; + } + } + if ((((((DLTensor*)out)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)out)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)out)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"hc_head_fuse_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)out)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)out)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)out)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_37; + result_37.type_index = kTVMFFINone; + result_37.zero_padding = 0; + result_37.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_37) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)hc_head_fuse_tilelang_residual_shape)[0]) != ((int32_t)((int64_t*)hc_head_fuse_tilelang_out_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"hc_head_fuse_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)hc_head_fuse_tilelang_out_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)hc_head_fuse_tilelang_residual_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_38; + result_38.type_index = kTVMFFINone; + result_38.zero_padding = 0; + result_38.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_38) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)hc_head_fuse_tilelang_out_shape)[1]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"hc_head_fuse_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)hc_head_fuse_tilelang_out_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_39; + result_39.type_index = kTVMFFINone; + result_39.zero_padding = 0; + result_39.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_39) != 0) { + return -1; + } + } + int32_t condval_11; + if ((hc_head_fuse_tilelang_out_strides == NULL)) { + condval_11 = 1; + } else { + condval_11 = ((int32_t)((int64_t*)hc_head_fuse_tilelang_out_strides)[1]); + } + if (condval_11 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"hc_head_fuse_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_12; + if ((hc_head_fuse_tilelang_out_strides == NULL)) { + condval_12 = 1; + } else { + condval_12 = ((int32_t)((int64_t*)hc_head_fuse_tilelang_out_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_12); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_40; + result_40.type_index = kTVMFFINone; + result_40.zero_padding = 0; + result_40.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_40) != 0) { + return -1; + } + } + int32_t condval_13; + if ((hc_head_fuse_tilelang_out_strides == NULL)) { + condval_13 = 1; + } else { + condval_13 = ((int32_t)((int64_t*)hc_head_fuse_tilelang_out_strides)[0]); + } + if ((condval_13 != 4096) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"hc_head_fuse_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_41; + result_41.type_index = kTVMFFINone; + result_41.zero_padding = 0; + result_41.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_41) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)out)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"hc_head_fuse_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)out)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_42; + result_42.type_index = kTVMFFINone; + result_42.zero_padding = 0; + result_42.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_42) != 0) { + return -1; + } + } + if ((((DLTensor*)out)[0].device.device_id) != (((DLTensor*)residual)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"hc_head_fuse_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)out)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_43; + result_43.type_index = kTVMFFINone; + result_43.zero_padding = 0; + result_43.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_43) != 0) { + return -1; + } + } + if ((((DLTensor*)out)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"hc_head_fuse_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)out)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_44; + result_44.type_index = kTVMFFINone; + result_44.zero_padding = 0; + result_44.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_44) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (out_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"hc_head_fuse_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"out"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_45; + result_45.type_index = kTVMFFINone; + result_45.zero_padding = 0; + result_45.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_45) != 0) { + return -1; + } + } + } else { + } + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = ((int64_t)2); + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = ((int64_t)dev_id); + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + if (__tvm_set_device_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_set_device", &__tvm_set_device_packed) != 0) { + return -1; + } + } + TVMFFIAny result_46; + result_46.type_index = kTVMFFINone; + result_46.zero_padding = 0; + result_46.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_set_device_packed, (TVMFFIAny*) stack_ffi_any, 2, &result_46) != 0) { + return -1; + } + if (fn_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = fn_1; + if (hc_base_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = hc_base_1; + if (hc_scale_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = hc_scale_1; + if (out_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_ptr) = out_1; + if (residual_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_ptr) = residual_1; + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = ((int64_t)num_tokens); + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = ((int64_t)num_tokens); + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = ((int64_t)128); + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = ((int64_t)1); + (((TVMFFIAny*)stack_ffi_any)[9].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[9].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[9].v_int64) = ((int64_t)1); + (((TVMFFIAny*)stack_ffi_any)[10].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[10].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[10].v_int64) = ((int64_t)16896); + (((TVMFFIAny*)stack_ffi_any)[11].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[11].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[11].v_int64) = (int64_t)0; + if (hc_head_fuse_tilelang_kernel_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "hc_head_fuse_tilelang_kernel", &hc_head_fuse_tilelang_kernel_packed) != 0) { + return -1; + } + } + TVMFFIAny result_47; + result_47.type_index = kTVMFFINone; + result_47.zero_padding = 0; + result_47.v_int64 = 0; + if (TVMFFIFunctionCall(hc_head_fuse_tilelang_kernel_packed, (TVMFFIAny*) stack_ffi_any, 11, &result_47) != 0) { + return -1; + } + return 0; +} + +// CodegenC: NOTE: Auto-generated entry function +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_main(void* self, void* args,int num_args, void* result) { + return __tvm_ffi_hc_head_fuse_tilelang(self, args, num_args, result); +} diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/bc130d0880c8dc66c0a86cfbe52a5accea0d7723ef84286eda1809080514e34c/params.pkl b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/bc130d0880c8dc66c0a86cfbe52a5accea0d7723ef84286eda1809080514e34c/params.pkl new file mode 100644 index 0000000..e2fd8ad Binary files /dev/null and b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/bc130d0880c8dc66c0a86cfbe52a5accea0d7723ef84286eda1809080514e34c/params.pkl differ diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/c0ef72219d5280025634d12a15beae51ea48dcaded4066ba7f411defa4b60bff/device_kernel.cu b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/c0ef72219d5280025634d12a15beae51ea48dcaded4066ba7f411defa4b60bff/device_kernel.cu new file mode 100644 index 0000000..5bfbedc --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/c0ef72219d5280025634d12a15beae51ea48dcaded4066ba7f411defa4b60bff/device_kernel.cu @@ -0,0 +1,424 @@ +#include +#include +#include +#include +#include +#include +#include +#ifdef ENABLE_BF16 +#include +#endif + +extern "C" __global__ void mhc_pre_big_fuse_with_norm_tilelang_kernel(float* comb_mix, const float* gemm_out_mul, const float* gemm_out_sqrsum, const float* hc_base, const float* hc_scale, bfloat16_t* layer_input, const bfloat16_t* norm_weight, float* post_mix, const bfloat16_t* residual, int num_tokens); +extern "C" __global__ void __launch_bounds__(96, 1) mhc_pre_big_fuse_with_norm_tilelang_kernel(float* comb_mix, const float* gemm_out_mul, const float* gemm_out_sqrsum, const float* hc_base, const float* hc_scale, bfloat16_t* layer_input, const bfloat16_t* norm_weight, float* post_mix, const bfloat16_t* residual, int num_tokens) { + extern __shared__ __align__(1024) uchar buf_dyn_shmem[]; + float mixes[1]; + float rms[1]; + float cm[1]; + float row_max[1]; + float row_sum[1]; + float col_sum[1]; + float sumsq_per_pos[16]; + float sumsq[1]; + float rsqrt_norm[1]; + float xl[64]; + float ol[16]; + bfloat16_t xs_local_cast[8]; + bfloat16_t xs_local_cast_1[8]; + bfloat16_t xs_local_cast_2[8]; + float w_local[16]; + float ol_1[16]; + bfloat16_t w_shared_local_cast_3[8]; + bfloat16_t output_shared_local_cast_4[8]; + bfloat16_t layer_input_local_cast_5[8]; + bfloat16_t w_shared_local_cast_6[8]; + bfloat16_t output_shared_local_cast_7[8]; + bfloat16_t layer_input_local_cast_8[8]; + bfloat16_t w_shared_local_cast_9[8]; + bfloat16_t output_shared_local_cast_10[8]; + bfloat16_t layer_input_local_cast_11[8]; + mixes[0] = 0x0p+0f/*0.000000e+00*/; + rms[0] = 0x0p+0f/*0.000000e+00*/; + cudaGridDependencySynchronize(); + for (int i_split = 0; i_split < 9; ++i_split) { + rms[0] = (rms[0] + gemm_out_sqrsum[((((int64_t)i_split) * ((int64_t)num_tokens)) + ((int64_t)((int)blockIdx.x)))]); + } + rms[0] = rsqrtf(((rms[0] / 0x1p+14f/*1.638400e+04*/) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + mixes[0] = 0x0p+0f/*0.000000e+00*/; + for (int i_split_1 = 0; i_split_1 < 9; ++i_split_1) { + mixes[0] = (mixes[0] + gemm_out_mul[(((((int64_t)((int)blockIdx.x)) * (int64_t)24) + ((((int64_t)i_split_1) * ((int64_t)num_tokens)) * (int64_t)24)) + (((int64_t)((int)threadIdx.x)) % (int64_t)24))]); + } + mixes[0] = (mixes[0] * rms[0]); + if ((((int)threadIdx.x) / 24) == 0) { + ((float*)buf_dyn_shmem)[(((int)threadIdx.x) % 24)] = mixes[0]; + } + __syncthreads(); + if (((int)threadIdx.x) < 32) { + if (((int)threadIdx.x) < 4) { + post_mix[((((int64_t)((int)blockIdx.x)) * (int64_t)4) + ((int64_t)((int)threadIdx.x)))] = ((0x1p+0f/*1.000000e+00*/ / (0x1p+0f/*1.000000e+00*/ + expf((0x0p+0f/*0.000000e+00*/ - ((((float*)buf_dyn_shmem)[(((int)threadIdx.x) + 4)] * hc_scale[1]) + hc_base[(((int)threadIdx.x) + 4)]))))) * 0x1p+1f/*2.000000e+00*/); + } + cm[0] = ((((float*)buf_dyn_shmem)[((((int)threadIdx.x) & 15) + 8)] * hc_scale[2]) + hc_base[((((int)threadIdx.x) & 15) + 8)]); + row_max[0] = -CUDART_INF_F; + row_max[0] = max(row_max[0], cm[0]); + row_max[0] = tl::AllReduce>::run(row_max[0]); + cm[0] = expf((cm[0] - row_max[0])); + row_sum[0] = 0x0p+0f/*0.000000e+00*/; + row_sum[0] = (row_sum[0] + cm[0]); + row_sum[0] = tl::AllReduce>::run(row_sum[0]); + cm[0] = ((cm[0] / row_sum[0]) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/); + col_sum[0] = 0x0p+0f/*0.000000e+00*/; + col_sum[0] = (col_sum[0] + cm[0]); + col_sum[0] = tl::AllReduce>::run(col_sum[0]); + cm[0] = (cm[0] / (col_sum[0] + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + for (int __1 = 0; __1 < 19; ++__1) { + row_sum[0] = 0x0p+0f/*0.000000e+00*/; + row_sum[0] = (row_sum[0] + cm[0]); + row_sum[0] = tl::AllReduce>::run(row_sum[0]); + cm[0] = (cm[0] / (row_sum[0] + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + col_sum[0] = 0x0p+0f/*0.000000e+00*/; + col_sum[0] = (col_sum[0] + cm[0]); + col_sum[0] = tl::AllReduce>::run(col_sum[0]); + cm[0] = (cm[0] / (col_sum[0] + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + } + if ((((int)threadIdx.x) >> 4) == 0) { + comb_mix[((((int64_t)((int)blockIdx.x)) * (int64_t)16) + (((int64_t)((int)threadIdx.x)) & (int64_t)15))] = cm[0]; + } + } else { + if (((int)threadIdx.x) < 36) { + ((float*)buf_dyn_shmem)[(((int)threadIdx.x) + 7224)] = ((0x1p+0f/*1.000000e+00*/ / (0x1p+0f/*1.000000e+00*/ + expf((0x0p+0f/*0.000000e+00*/ - ((((float*)buf_dyn_shmem)[(((int)threadIdx.x) - 32)] * hc_scale[0]) + hc_base[(((int)threadIdx.x) - 32)]))))) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/); + } + #pragma unroll + for (int i = 0; i < 4; ++i) { + float broadcast_var = 0x0p+0f/*0.000000e+00*/; + *(float4*)(sumsq_per_pos + (i * 4)) = make_float4(broadcast_var, broadcast_var, broadcast_var, broadcast_var); + } + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_1 = 0; i_1 < 8; ++i_1) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i_1 >> 1) * 1024) + (((((i_1 * 64) + ((int)threadIdx.x)) + 96) & 127) * 8)) + 48)])), (&(residual[(((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + ((((int64_t)i_1) >> (int64_t)1) * (int64_t)4096)) + (((((((int64_t)i_1) * (int64_t)64) + ((int64_t)((int)threadIdx.x))) + (int64_t)96) & (int64_t)127) * (int64_t)8))]))); + } + tl::cp_async_commit(); + #pragma unroll + for (int i_2 = 0; i_2 < 8; ++i_2) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i_2 >> 1) * 1024) + (((((i_2 * 64) + ((int)threadIdx.x)) + 96) & 127) * 8)) + 4144)])), (&(residual[((((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + ((((int64_t)i_2) >> (int64_t)1) * (int64_t)4096)) + (((((((int64_t)i_2) * (int64_t)64) + ((int64_t)((int)threadIdx.x))) + (int64_t)96) & (int64_t)127) * (int64_t)8)) + (int64_t)1024)]))); + } + tl::cp_async_commit(); + for (int i0_h = 0; i0_h < 2; ++i0_h) { + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_3 = 0; i_3 < 8; ++i_3) { + *(uint4*)(xs_local_cast + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + ((((i0_h * 4096) + (i_3 * 512)) + (((int)threadIdx.x) * 8)) - 208)); + for (int vec = 0; vec < 2; ++vec) { + float4 __2; + uint2 v_ = *(uint2*)(xs_local_cast + (vec * 4)); + ((float2*)(&__2))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v_))[0]); + ((float2*)(&__2))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v_))[1]); + *(float4*)(xl + ((i_3 * 8) + (vec * 4))) = __2; + } + } + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_4 = 0; i_4 < 8; ++i_4) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i0_h * 4096) + ((i_4 >> 1) * 1024)) + (((((i_4 * 64) + ((int)threadIdx.x)) + 96) & 127) * 8)) + 48)])), (&(residual[(((((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + ((((int64_t)i_4) >> (int64_t)1) * (int64_t)4096)) + (((int64_t)i0_h) * (int64_t)1024)) + (((((((int64_t)i_4) * (int64_t)64) + ((int64_t)((int)threadIdx.x))) + (int64_t)96) & (int64_t)127) * (int64_t)8)) + (int64_t)2048)]))); + } + tl::cp_async_commit(); + #pragma unroll + for (int i_5 = 0; i_5 < 4; ++i_5) { + float broadcast_var_1 = 0x0p+0f/*0.000000e+00*/; + *(float4*)(ol + (i_5 * 4)) = make_float4(broadcast_var_1, broadcast_var_1, broadcast_var_1, broadcast_var_1); + } + tl::__sync_thread_partial<3, 64>(); + for (int i_hc = 0; i_hc < 4; ++i_hc) { + float pre = ((float*)buf_dyn_shmem)[(i_hc + 7256)]; + #pragma unroll + for (int i_6 = 0; i_6 < 16; ++i_6) { + ol[i_6] = (ol[i_6] + (pre * xl[((i_hc * 16) + i_6)])); + } + } + #pragma unroll + for (int i_7 = 0; i_7 < 4; ++i_7) { + float4 __3; + float4 v__1 = *(float4*)(sumsq_per_pos + (i_7 * 4)); + float4 __4; + float4 v__2 = *(float4*)(ol + (i_7 * 4)); + __4.x = (v__2.x*v__2.x); + __4.y = (v__2.y*v__2.y); + __4.z = (v__2.z*v__2.z); + __4.w = (v__2.w*v__2.w); + __3.x = (v__1.x+__4.x); + __3.y = (v__1.y+__4.y); + __3.z = (v__1.z+__4.z); + __3.w = (v__1.w+__4.w); + *(float4*)(sumsq_per_pos + (i_7 * 4)) = __3; + uint2 __5; + float4 v__3 = *(float4*)(ol + (i_7 * 4)); + (reinterpret_cast<__nv_bfloat162*>(&__5))[0] = __float22bfloat162_rn(((float2*)(&v__3))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__5))[1] = __float22bfloat162_rn(((float2*)(&v__3))[1]); + *(uint2*)(((bfloat16_t*)buf_dyn_shmem) + (((((i0_h * 1024) + ((i_7 >> 1) * 512)) + (((int)threadIdx.x) * 8)) + ((i_7 & 1) * 4)) + 7984)) = __5; + } + } + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_8 = 0; i_8 < 8; ++i_8) { + *(uint4*)(xs_local_cast_1 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_8 * 512) + (((int)threadIdx.x) * 8)) - 208)); + for (int vec_1 = 0; vec_1 < 2; ++vec_1) { + float4 __6; + uint2 v__4 = *(uint2*)(xs_local_cast_1 + (vec_1 * 4)); + ((float2*)(&__6))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__4))[0]); + ((float2*)(&__6))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__4))[1]); + *(float4*)(xl + ((i_8 * 8) + (vec_1 * 4))) = __6; + } + } + #pragma unroll + for (int i_9 = 0; i_9 < 4; ++i_9) { + float broadcast_var_2 = 0x0p+0f/*0.000000e+00*/; + *(float4*)(ol + (i_9 * 4)) = make_float4(broadcast_var_2, broadcast_var_2, broadcast_var_2, broadcast_var_2); + } + for (int i_hc_1 = 0; i_hc_1 < 4; ++i_hc_1) { + float pre_1 = ((float*)buf_dyn_shmem)[(i_hc_1 + 7256)]; + #pragma unroll + for (int i_10 = 0; i_10 < 16; ++i_10) { + ol[i_10] = (ol[i_10] + (pre_1 * xl[((i_hc_1 * 16) + i_10)])); + } + } + #pragma unroll + for (int i_11 = 0; i_11 < 4; ++i_11) { + float4 __7; + float4 v__5 = *(float4*)(sumsq_per_pos + (i_11 * 4)); + float4 __8; + float4 v__6 = *(float4*)(ol + (i_11 * 4)); + __8.x = (v__6.x*v__6.x); + __8.y = (v__6.y*v__6.y); + __8.z = (v__6.z*v__6.z); + __8.w = (v__6.w*v__6.w); + __7.x = (v__5.x+__8.x); + __7.y = (v__5.y+__8.y); + __7.z = (v__5.z+__8.z); + __7.w = (v__5.w+__8.w); + *(float4*)(sumsq_per_pos + (i_11 * 4)) = __7; + uint2 __9; + float4 v__7 = *(float4*)(ol + (i_11 * 4)); + (reinterpret_cast<__nv_bfloat162*>(&__9))[0] = __float22bfloat162_rn(((float2*)(&v__7))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__9))[1] = __float22bfloat162_rn(((float2*)(&v__7))[1]); + *(uint2*)(((bfloat16_t*)buf_dyn_shmem) + (((((i_11 >> 1) * 512) + (((int)threadIdx.x) * 8)) + ((i_11 & 1) * 4)) + 10032)) = __9; + } + tl::cp_async_wait<0>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_12 = 0; i_12 < 8; ++i_12) { + *(uint4*)(xs_local_cast_2 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_12 * 512) + (((int)threadIdx.x) * 8)) + 3888)); + for (int vec_2 = 0; vec_2 < 2; ++vec_2) { + float4 __10; + uint2 v__8 = *(uint2*)(xs_local_cast_2 + (vec_2 * 4)); + ((float2*)(&__10))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__8))[0]); + ((float2*)(&__10))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__8))[1]); + *(float4*)(xl + ((i_12 * 8) + (vec_2 * 4))) = __10; + } + } + #pragma unroll + for (int i_13 = 0; i_13 < 4; ++i_13) { + float broadcast_var_3 = 0x0p+0f/*0.000000e+00*/; + *(float4*)(ol + (i_13 * 4)) = make_float4(broadcast_var_3, broadcast_var_3, broadcast_var_3, broadcast_var_3); + } + for (int i_hc_2 = 0; i_hc_2 < 4; ++i_hc_2) { + float pre_2 = ((float*)buf_dyn_shmem)[(i_hc_2 + 7256)]; + #pragma unroll + for (int i_14 = 0; i_14 < 16; ++i_14) { + ol[i_14] = (ol[i_14] + (pre_2 * xl[((i_hc_2 * 16) + i_14)])); + } + } + #pragma unroll + for (int i_15 = 0; i_15 < 4; ++i_15) { + float4 __11; + float4 v__9 = *(float4*)(sumsq_per_pos + (i_15 * 4)); + float4 __12; + float4 v__10 = *(float4*)(ol + (i_15 * 4)); + __12.x = (v__10.x*v__10.x); + __12.y = (v__10.y*v__10.y); + __12.z = (v__10.z*v__10.z); + __12.w = (v__10.w*v__10.w); + __11.x = (v__9.x+__12.x); + __11.y = (v__9.y+__12.y); + __11.z = (v__9.z+__12.z); + __11.w = (v__9.w+__12.w); + *(float4*)(sumsq_per_pos + (i_15 * 4)) = __11; + uint2 __13; + float4 v__11 = *(float4*)(ol + (i_15 * 4)); + (reinterpret_cast<__nv_bfloat162*>(&__13))[0] = __float22bfloat162_rn(((float2*)(&v__11))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__13))[1] = __float22bfloat162_rn(((float2*)(&v__11))[1]); + *(uint2*)(((bfloat16_t*)buf_dyn_shmem) + (((((i_15 >> 1) * 512) + (((int)threadIdx.x) * 8)) + ((i_15 & 1) * 4)) + 11056)) = __13; + } + sumsq[0] = 0x0p+0f/*0.000000e+00*/; + #pragma unroll + for (int rv = 0; rv < 16; ++rv) { + sumsq[0] = (sumsq[0] + sumsq_per_pos[(((rv & 1) * 8) + (rv >> 1))]); + } + tl::__sync_thread_partial<3, 64>(); + sumsq[0] = tl::AllReduce>::run(sumsq[0], (&(((float*)buf_dyn_shmem)[7192]))); + rsqrt_norm[0] = rsqrtf(((sumsq[0] / 0x1p+12f/*4.096000e+03*/) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + #pragma unroll + for (int i_16 = 0; i_16 < 2; ++i_16) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[(((i_16 * 512) + (((int)threadIdx.x) * 8)) + 12080)])), (&(norm_weight[(((i_16 * 512) + (((int)threadIdx.x) * 8)) - 256)]))); + } + tl::cp_async_commit(); + #pragma unroll + for (int i_17 = 0; i_17 < 2; ++i_17) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[(((i_17 * 512) + (((int)threadIdx.x) * 8)) + 13104)])), (&(norm_weight[(((i_17 * 512) + (((int)threadIdx.x) * 8)) + 768)]))); + } + tl::cp_async_commit(); + for (int i0_h_1 = 0; i0_h_1 < 2; ++i0_h_1) { + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_18 = 0; i_18 < 2; ++i_18) { + *(uint4*)(w_shared_local_cast_3 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + ((((i0_h_1 * 1024) + (i_18 * 512)) + (((int)threadIdx.x) * 8)) + 12080)); + for (int vec_3 = 0; vec_3 < 2; ++vec_3) { + float4 __14; + uint2 v__12 = *(uint2*)(w_shared_local_cast_3 + (vec_3 * 4)); + ((float2*)(&__14))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__12))[0]); + ((float2*)(&__14))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__12))[1]); + *(float4*)(w_local + ((i_18 * 8) + (vec_3 * 4))) = __14; + } + } + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_19 = 0; i_19 < 2; ++i_19) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i0_h_1 * 1024) + (i_19 * 512)) + (((int)threadIdx.x) * 8)) + 12080)])), (&(norm_weight[((((i0_h_1 * 1024) + (i_19 * 512)) + (((int)threadIdx.x) * 8)) + 1792)]))); + } + tl::cp_async_commit(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_20 = 0; i_20 < 2; ++i_20) { + *(uint4*)(output_shared_local_cast_4 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + ((((i0_h_1 * 1024) + (i_20 * 512)) + (((int)threadIdx.x) * 8)) + 7984)); + for (int vec_4 = 0; vec_4 < 2; ++vec_4) { + float4 __15; + float4 __16; + float4 __17; + uint2 v__13 = *(uint2*)(output_shared_local_cast_4 + (vec_4 * 4)); + ((float2*)(&__17))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__13))[0]); + ((float2*)(&__17))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__13))[1]); + float4 v__14 = make_float4(rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0]); + __16.x = (__17.x*v__14.x); + __16.y = (__17.y*v__14.y); + __16.z = (__17.z*v__14.z); + __16.w = (__17.w*v__14.w); + float4 v__15 = *(float4*)(w_local + ((i_20 * 8) + (vec_4 * 4))); + __15.x = (__16.x*v__15.x); + __15.y = (__16.y*v__15.y); + __15.z = (__16.z*v__15.z); + __15.w = (__16.w*v__15.w); + *(float4*)(ol_1 + ((i_20 * 8) + (vec_4 * 4))) = __15; + } + } + #pragma unroll + for (int i_21 = 0; i_21 < 2; ++i_21) { + for (int vec_5 = 0; vec_5 < 2; ++vec_5) { + uint2 __18; + float4 v__16 = *(float4*)(ol_1 + ((i_21 * 8) + (vec_5 * 4))); + (reinterpret_cast<__nv_bfloat162*>(&__18))[0] = __float22bfloat162_rn(((float2*)(&v__16))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__18))[1] = __float22bfloat162_rn(((float2*)(&v__16))[1]); + *(uint2*)(layer_input_local_cast_5 + (vec_5 * 4)) = __18; + } + *(uint4*)(layer_input + (((((((int64_t)((int)blockIdx.x)) * (int64_t)4096) + (((int64_t)i0_h_1) * (int64_t)1024)) + (((int64_t)i_21) * (int64_t)512)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8)) - (int64_t)256)) = *(uint4*)(layer_input_local_cast_5 + 0); + } + } + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_22 = 0; i_22 < 2; ++i_22) { + *(uint4*)(w_shared_local_cast_6 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_22 * 512) + (((int)threadIdx.x) * 8)) + 12080)); + for (int vec_6 = 0; vec_6 < 2; ++vec_6) { + float4 __19; + uint2 v__17 = *(uint2*)(w_shared_local_cast_6 + (vec_6 * 4)); + ((float2*)(&__19))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__17))[0]); + ((float2*)(&__19))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__17))[1]); + *(float4*)(w_local + ((i_22 * 8) + (vec_6 * 4))) = __19; + } + } + #pragma unroll + for (int i_23 = 0; i_23 < 2; ++i_23) { + *(uint4*)(output_shared_local_cast_7 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_23 * 512) + (((int)threadIdx.x) * 8)) + 10032)); + for (int vec_7 = 0; vec_7 < 2; ++vec_7) { + float4 __20; + float4 __21; + float4 __22; + uint2 v__18 = *(uint2*)(output_shared_local_cast_7 + (vec_7 * 4)); + ((float2*)(&__22))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__18))[0]); + ((float2*)(&__22))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__18))[1]); + float4 v__19 = make_float4(rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0]); + __21.x = (__22.x*v__19.x); + __21.y = (__22.y*v__19.y); + __21.z = (__22.z*v__19.z); + __21.w = (__22.w*v__19.w); + float4 v__20 = *(float4*)(w_local + ((i_23 * 8) + (vec_7 * 4))); + __20.x = (__21.x*v__20.x); + __20.y = (__21.y*v__20.y); + __20.z = (__21.z*v__20.z); + __20.w = (__21.w*v__20.w); + *(float4*)(ol_1 + ((i_23 * 8) + (vec_7 * 4))) = __20; + } + } + #pragma unroll + for (int i_24 = 0; i_24 < 2; ++i_24) { + for (int vec_8 = 0; vec_8 < 2; ++vec_8) { + uint2 __23; + float4 v__21 = *(float4*)(ol_1 + ((i_24 * 8) + (vec_8 * 4))); + (reinterpret_cast<__nv_bfloat162*>(&__23))[0] = __float22bfloat162_rn(((float2*)(&v__21))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__23))[1] = __float22bfloat162_rn(((float2*)(&v__21))[1]); + *(uint2*)(layer_input_local_cast_8 + (vec_8 * 4)) = __23; + } + *(uint4*)(layer_input + ((((((int64_t)((int)blockIdx.x)) * (int64_t)4096) + (((int64_t)i_24) * (int64_t)512)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8)) + (int64_t)1792)) = *(uint4*)(layer_input_local_cast_8 + 0); + } + tl::cp_async_wait<0>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_25 = 0; i_25 < 2; ++i_25) { + *(uint4*)(w_shared_local_cast_9 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_25 * 512) + (((int)threadIdx.x) * 8)) + 13104)); + for (int vec_9 = 0; vec_9 < 2; ++vec_9) { + float4 __24; + uint2 v__22 = *(uint2*)(w_shared_local_cast_9 + (vec_9 * 4)); + ((float2*)(&__24))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__22))[0]); + ((float2*)(&__24))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__22))[1]); + *(float4*)(w_local + ((i_25 * 8) + (vec_9 * 4))) = __24; + } + } + #pragma unroll + for (int i_26 = 0; i_26 < 2; ++i_26) { + *(uint4*)(output_shared_local_cast_10 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_26 * 512) + (((int)threadIdx.x) * 8)) + 11056)); + for (int vec_10 = 0; vec_10 < 2; ++vec_10) { + float4 __25; + float4 __26; + float4 __27; + uint2 v__23 = *(uint2*)(output_shared_local_cast_10 + (vec_10 * 4)); + ((float2*)(&__27))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__23))[0]); + ((float2*)(&__27))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__23))[1]); + float4 v__24 = make_float4(rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0]); + __26.x = (__27.x*v__24.x); + __26.y = (__27.y*v__24.y); + __26.z = (__27.z*v__24.z); + __26.w = (__27.w*v__24.w); + float4 v__25 = *(float4*)(w_local + ((i_26 * 8) + (vec_10 * 4))); + __25.x = (__26.x*v__25.x); + __25.y = (__26.y*v__25.y); + __25.z = (__26.z*v__25.z); + __25.w = (__26.w*v__25.w); + *(float4*)(ol_1 + ((i_26 * 8) + (vec_10 * 4))) = __25; + } + } + #pragma unroll + for (int i_27 = 0; i_27 < 2; ++i_27) { + for (int vec_11 = 0; vec_11 < 2; ++vec_11) { + uint2 __28; + float4 v__26 = *(float4*)(ol_1 + ((i_27 * 8) + (vec_11 * 4))); + (reinterpret_cast<__nv_bfloat162*>(&__28))[0] = __float22bfloat162_rn(((float2*)(&v__26))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__28))[1] = __float22bfloat162_rn(((float2*)(&v__26))[1]); + *(uint2*)(layer_input_local_cast_11 + (vec_11 * 4)) = __28; + } + *(uint4*)(layer_input + ((((((int64_t)((int)blockIdx.x)) * (int64_t)4096) + (((int64_t)i_27) * (int64_t)512)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8)) + (int64_t)2816)) = *(uint4*)(layer_input_local_cast_11 + 0); + } + } + cudaTriggerProgrammaticLaunchCompletion(); +} + diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/c0ef72219d5280025634d12a15beae51ea48dcaded4066ba7f411defa4b60bff/host_kernel.cu b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/c0ef72219d5280025634d12a15beae51ea48dcaded4066ba7f411defa4b60bff/host_kernel.cu new file mode 100644 index 0000000..2f76fb5 --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/c0ef72219d5280025634d12a15beae51ea48dcaded4066ba7f411defa4b60bff/host_kernel.cu @@ -0,0 +1,3359 @@ +// tilelang target: c -keys=cpu +#define TVM_EXPORTS +#include "tvm/runtime/base.h" +#include "tvm/runtime/c_backend_api.h" +#include "tvm/ffi/c_api.h" +#include +#include +#include +#ifdef __OBJC__ +#include "tvm/runtime/device_api.h" +#include "tvm/ffi/function.h" +#include +#include +#include +#endif +void* __tvm_ffi__library_ctx = NULL; +static void* __tvm_error_ndim_mismatch_packed = NULL; +static void* __tvm_error_dtype_mismatch_packed = NULL; +static void* __tvm_error_expect_eq_packed = NULL; +static void* __tvm_error_constraint_violation_packed = NULL; +static void* __tvm_error_byte_offset_mismatch_packed = NULL; +static void* __tvm_error_device_type_mismatch_packed = NULL; +static void* __tvm_error_null_ptr_packed = NULL; +static void* __tvm_set_device_packed = NULL; +static void* mhc_pre_big_fuse_with_norm_tilelang_kernel_packed = NULL; +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_mhc_pre_big_fuse_with_norm_tilelang(void* self_handle, void* args, int32_t num_args, void* result); +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_mhc_pre_big_fuse_with_norm_tilelang(void* self_handle, void* args, int32_t num_args, void* result) { + __attribute__((aligned(64))) TVMFFIAny stack[16]; + void* stack_ffi_any = stack; + if (!((num_args == 9))) { + char __tvm_assert_msg_buf[512]; + snprintf(__tvm_assert_msg_buf, 512, "%s; expected: %lld, got: %lld", "mhc_pre_big_fuse_with_norm_tilelang: num_args should be 9", (long long)(num_args), (long long)(9)); + TVMFFIErrorSetRaisedFromCStr("RuntimeError", __tvm_assert_msg_buf); + return -1; + } + if (!(!(args == NULL))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang: args pointer is NULL"); + return -1; + } + int32_t gemm_out_mul_type_index = (((TVMFFIAny*)args)[0].type_index); + if (!(((((gemm_out_mul_type_index == 0) || (gemm_out_mul_type_index == 4)) || (gemm_out_mul_type_index == 7)) || (64 <= gemm_out_mul_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input gemm_out_mul expected pointer or tensor handle"); + return -1; + } + int32_t gemm_out_sqrsum_type_index = (((TVMFFIAny*)args)[1].type_index); + if (!(((((gemm_out_sqrsum_type_index == 0) || (gemm_out_sqrsum_type_index == 4)) || (gemm_out_sqrsum_type_index == 7)) || (64 <= gemm_out_sqrsum_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input gemm_out_sqrsum expected pointer or tensor handle"); + return -1; + } + int32_t hc_scale_type_index = (((TVMFFIAny*)args)[2].type_index); + if (!(((((hc_scale_type_index == 0) || (hc_scale_type_index == 4)) || (hc_scale_type_index == 7)) || (64 <= hc_scale_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input hc_scale expected pointer or tensor handle"); + return -1; + } + int32_t hc_base_type_index = (((TVMFFIAny*)args)[3].type_index); + if (!(((((hc_base_type_index == 0) || (hc_base_type_index == 4)) || (hc_base_type_index == 7)) || (64 <= hc_base_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input hc_base expected pointer or tensor handle"); + return -1; + } + int32_t residual_type_index = (((TVMFFIAny*)args)[4].type_index); + if (!(((((residual_type_index == 0) || (residual_type_index == 4)) || (residual_type_index == 7)) || (64 <= residual_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input residual expected pointer or tensor handle"); + return -1; + } + int32_t post_mix_type_index = (((TVMFFIAny*)args)[5].type_index); + if (!(((((post_mix_type_index == 0) || (post_mix_type_index == 4)) || (post_mix_type_index == 7)) || (64 <= post_mix_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input post_mix expected pointer or tensor handle"); + return -1; + } + int32_t comb_mix_type_index = (((TVMFFIAny*)args)[6].type_index); + if (!(((((comb_mix_type_index == 0) || (comb_mix_type_index == 4)) || (comb_mix_type_index == 7)) || (64 <= comb_mix_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input comb_mix expected pointer or tensor handle"); + return -1; + } + int32_t layer_input_type_index = (((TVMFFIAny*)args)[7].type_index); + if (!(((((layer_input_type_index == 0) || (layer_input_type_index == 4)) || (layer_input_type_index == 7)) || (64 <= layer_input_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input layer_input expected pointer or tensor handle"); + return -1; + } + int32_t norm_weight_type_index = (((TVMFFIAny*)args)[8].type_index); + if (!(((((norm_weight_type_index == 0) || (norm_weight_type_index == 4)) || (norm_weight_type_index == 7)) || (64 <= norm_weight_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input norm_weight expected pointer or tensor handle"); + return -1; + } + void* gemm_out_mul = ((gemm_out_mul_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[0].v_ptr) + 24)) : (((TVMFFIAny*)args)[0].v_ptr)); + void* gemm_out_sqrsum = ((gemm_out_sqrsum_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[1].v_ptr) + 24)) : (((TVMFFIAny*)args)[1].v_ptr)); + void* hc_scale = ((hc_scale_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[2].v_ptr) + 24)) : (((TVMFFIAny*)args)[2].v_ptr)); + void* hc_base = ((hc_base_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[3].v_ptr) + 24)) : (((TVMFFIAny*)args)[3].v_ptr)); + void* residual = ((residual_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[4].v_ptr) + 24)) : (((TVMFFIAny*)args)[4].v_ptr)); + void* post_mix = ((post_mix_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[5].v_ptr) + 24)) : (((TVMFFIAny*)args)[5].v_ptr)); + void* comb_mix = ((comb_mix_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[6].v_ptr) + 24)) : (((TVMFFIAny*)args)[6].v_ptr)); + void* layer_input = ((layer_input_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[7].v_ptr) + 24)) : (((TVMFFIAny*)args)[7].v_ptr)); + void* norm_weight = ((norm_weight_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[8].v_ptr) + 24)) : (((TVMFFIAny*)args)[8].v_ptr)); + bool mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_is_null = (gemm_out_mul == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.gemm_out_mul is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_is_null = (gemm_out_sqrsum == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.gemm_out_sqrsum is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_hc_scale_is_null = (hc_scale == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_hc_scale_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.hc_scale is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_hc_base_is_null = (hc_base == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_hc_base_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.hc_base is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_residual_is_null = (residual == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_residual_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.residual is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_post_mix_is_null = (post_mix == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_post_mix_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.post_mix is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_comb_mix_is_null = (comb_mix == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_comb_mix_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.comb_mix is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_layer_input_is_null = (layer_input == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_layer_input_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.layer_input is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_norm_weight_is_null = (norm_weight == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_norm_weight_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.norm_weight is expected to have non-NULL pointer"); + return -1; + } + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape = (((DLTensor*)gemm_out_mul)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape = (((DLTensor*)gemm_out_sqrsum)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_hc_scale_shape = (((DLTensor*)hc_scale)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_hc_base_shape = (((DLTensor*)hc_base)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_residual_shape = (((DLTensor*)residual)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape = (((DLTensor*)post_mix)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape = (((DLTensor*)comb_mix)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape = (((DLTensor*)layer_input)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_norm_weight_shape = (((DLTensor*)norm_weight)[0].shape); + if ((((DLTensor*)gemm_out_mul)[0].ndim) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_1; + result_1.type_index = kTVMFFINone; + result_1.zero_padding = 0; + result_1.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_1) != 0) { + return -1; + } + } + if (!((bool)1)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "Symbolic shape variable num_tokens requires at least one non-null buffer among: mhc_pre_big_fuse_with_norm_tilelang.gemm_out_mul, mhc_pre_big_fuse_with_norm_tilelang.gemm_out_sqrsum, mhc_pre_big_fuse_with_norm_tilelang.residual, mhc_pre_big_fuse_with_norm_tilelang.post_mix, mhc_pre_big_fuse_with_norm_tilelang.comb_mix, mhc_pre_big_fuse_with_norm_tilelang.layer_input"); + return -1; + } + int32_t num_tokens = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]); + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides = (((DLTensor*)gemm_out_mul)[0].strides); + int32_t dev_id = (((DLTensor*)gemm_out_mul)[0].device.device_id); + void* gemm_out_mul_1 = (((DLTensor*)gemm_out_mul)[0].data); + if ((((DLTensor*)gemm_out_sqrsum)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_2; + result_2.type_index = kTVMFFINone; + result_2.zero_padding = 0; + result_2.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_2) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides = (((DLTensor*)gemm_out_sqrsum)[0].strides); + void* gemm_out_sqrsum_1 = (((DLTensor*)gemm_out_sqrsum)[0].data); + if ((((DLTensor*)hc_scale)[0].ndim) != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_3; + result_3.type_index = kTVMFFINone; + result_3.zero_padding = 0; + result_3.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_3) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides = (((DLTensor*)hc_scale)[0].strides); + void* hc_scale_1 = (((DLTensor*)hc_scale)[0].data); + if ((((DLTensor*)hc_base)[0].ndim) != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_4; + result_4.type_index = kTVMFFINone; + result_4.zero_padding = 0; + result_4.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_4) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides = (((DLTensor*)hc_base)[0].strides); + void* hc_base_1 = (((DLTensor*)hc_base)[0].data); + if ((((DLTensor*)residual)[0].ndim) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_5; + result_5.type_index = kTVMFFINone; + result_5.zero_padding = 0; + result_5.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_5) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_residual_strides = (((DLTensor*)residual)[0].strides); + void* residual_1 = (((DLTensor*)residual)[0].data); + if ((((DLTensor*)post_mix)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_6; + result_6.type_index = kTVMFFINone; + result_6.zero_padding = 0; + result_6.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_6) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides = (((DLTensor*)post_mix)[0].strides); + void* post_mix_1 = (((DLTensor*)post_mix)[0].data); + if ((((DLTensor*)comb_mix)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_7; + result_7.type_index = kTVMFFINone; + result_7.zero_padding = 0; + result_7.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_7) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides = (((DLTensor*)comb_mix)[0].strides); + void* comb_mix_1 = (((DLTensor*)comb_mix)[0].data); + if ((((DLTensor*)layer_input)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_8; + result_8.type_index = kTVMFFINone; + result_8.zero_padding = 0; + result_8.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_8) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides = (((DLTensor*)layer_input)[0].strides); + void* layer_input_1 = (((DLTensor*)layer_input)[0].data); + if ((((DLTensor*)norm_weight)[0].ndim) != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_9; + result_9.type_index = kTVMFFINone; + result_9.zero_padding = 0; + result_9.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_9) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides = (((DLTensor*)norm_weight)[0].strides); + void* norm_weight_1 = (((DLTensor*)norm_weight)[0].data); + if ((((((DLTensor*)gemm_out_mul)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)gemm_out_mul)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)gemm_out_mul)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_10; + result_10.type_index = kTVMFFINone; + result_10.zero_padding = 0; + result_10.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_10) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[0]) != 9) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)9; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_11; + result_11.type_index = kTVMFFINone; + result_11.zero_padding = 0; + result_11.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_11) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[2]) != 24) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)24; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[2])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_12; + result_12.type_index = kTVMFFINone; + result_12.zero_padding = 0; + result_12.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_12) != 0) { + return -1; + } + } + int32_t condval; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval = 1; + } else { + condval = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[2]); + } + if (condval != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_1; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval_1 = 1; + } else { + condval_1 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[2]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_1); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_13; + result_13.type_index = kTVMFFINone; + result_13.zero_padding = 0; + result_13.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_13) != 0) { + return -1; + } + } + int32_t condval_2; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval_2 = 1; + } else { + condval_2 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[1]); + } + if ((condval_2 != 24) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_14; + result_14.type_index = kTVMFFINone; + result_14.zero_padding = 0; + result_14.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_14) != 0) { + return -1; + } + } + int32_t condval_3; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval_3 = 1; + } else { + condval_3 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[0]); + } + if (((num_tokens * 24) != condval_3) && (num_tokens != 0)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_15; + result_15.type_index = kTVMFFINone; + result_15.zero_padding = 0; + result_15.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_15) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)gemm_out_mul)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_16; + result_16.type_index = kTVMFFINone; + result_16.zero_padding = 0; + result_16.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_16) != 0) { + return -1; + } + } + if ((((DLTensor*)gemm_out_mul)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_17; + result_17.type_index = kTVMFFINone; + result_17.zero_padding = 0; + result_17.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_17) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (gemm_out_mul_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_18; + result_18.type_index = kTVMFFINone; + result_18.zero_padding = 0; + result_18.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_18) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)gemm_out_sqrsum)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)gemm_out_sqrsum)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)gemm_out_sqrsum)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_19; + result_19.type_index = kTVMFFINone; + result_19.zero_padding = 0; + result_19.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_19) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[0]) != 9) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)9; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_20; + result_20.type_index = kTVMFFINone; + result_20.zero_padding = 0; + result_20.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_20) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[1])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_21; + result_21.type_index = kTVMFFINone; + result_21.zero_padding = 0; + result_21.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_21) != 0) { + return -1; + } + } + int32_t condval_4; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides == NULL)) { + condval_4 = 1; + } else { + condval_4 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides)[1]); + } + if ((condval_4 != 1) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_22; + result_22.type_index = kTVMFFINone; + result_22.zero_padding = 0; + result_22.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_22) != 0) { + return -1; + } + } + int32_t condval_5; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides == NULL)) { + condval_5 = 1; + } else { + condval_5 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides)[0]); + } + if ((((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != condval_5) && (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != 0)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_23; + result_23.type_index = kTVMFFINone; + result_23.zero_padding = 0; + result_23.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_23) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)gemm_out_sqrsum)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_24; + result_24.type_index = kTVMFFINone; + result_24.zero_padding = 0; + result_24.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_24) != 0) { + return -1; + } + } + if ((((DLTensor*)gemm_out_sqrsum)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_25; + result_25.type_index = kTVMFFINone; + result_25.zero_padding = 0; + result_25.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_25) != 0) { + return -1; + } + } + if ((((DLTensor*)gemm_out_sqrsum)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_26; + result_26.type_index = kTVMFFINone; + result_26.zero_padding = 0; + result_26.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_26) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (gemm_out_sqrsum_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_27; + result_27.type_index = kTVMFFINone; + result_27.zero_padding = 0; + result_27.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_27) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)hc_scale)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)hc_scale)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)hc_scale)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_28; + result_28.type_index = kTVMFFINone; + result_28.zero_padding = 0; + result_28.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_28) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_shape)[0]) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_29; + result_29.type_index = kTVMFFINone; + result_29.zero_padding = 0; + result_29.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_29) != 0) { + return -1; + } + } + int32_t condval_6; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides == NULL)) { + condval_6 = 1; + } else { + condval_6 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides)[0]); + } + if (condval_6 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_7; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides == NULL)) { + condval_7 = 1; + } else { + condval_7 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides)[0]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_7); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_30; + result_30.type_index = kTVMFFINone; + result_30.zero_padding = 0; + result_30.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_30) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)hc_scale)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_31; + result_31.type_index = kTVMFFINone; + result_31.zero_padding = 0; + result_31.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_31) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_scale)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_32; + result_32.type_index = kTVMFFINone; + result_32.zero_padding = 0; + result_32.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_32) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_scale)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_33; + result_33.type_index = kTVMFFINone; + result_33.zero_padding = 0; + result_33.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_33) != 0) { + return -1; + } + } + if (hc_scale_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_34; + result_34.type_index = kTVMFFINone; + result_34.zero_padding = 0; + result_34.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_34) != 0) { + return -1; + } + } + if ((((((DLTensor*)hc_base)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)hc_base)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)hc_base)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_35; + result_35.type_index = kTVMFFINone; + result_35.zero_padding = 0; + result_35.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_35) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_shape)[0]) != 24) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)24; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_36; + result_36.type_index = kTVMFFINone; + result_36.zero_padding = 0; + result_36.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_36) != 0) { + return -1; + } + } + int32_t condval_8; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides == NULL)) { + condval_8 = 1; + } else { + condval_8 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides)[0]); + } + if (condval_8 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_9; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides == NULL)) { + condval_9 = 1; + } else { + condval_9 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides)[0]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_9); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_37; + result_37.type_index = kTVMFFINone; + result_37.zero_padding = 0; + result_37.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_37) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)hc_base)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_38; + result_38.type_index = kTVMFFINone; + result_38.zero_padding = 0; + result_38.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_38) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_base)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_39; + result_39.type_index = kTVMFFINone; + result_39.zero_padding = 0; + result_39.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_39) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_base)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_40; + result_40.type_index = kTVMFFINone; + result_40.zero_padding = 0; + result_40.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_40) != 0) { + return -1; + } + } + if (hc_base_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_41; + result_41.type_index = kTVMFFINone; + result_41.zero_padding = 0; + result_41.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_41) != 0) { + return -1; + } + } + if ((((((DLTensor*)residual)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)residual)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)residual)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)residual)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)residual)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_42; + result_42.type_index = kTVMFFINone; + result_42.zero_padding = 0; + result_42.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_42) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_43; + result_43.type_index = kTVMFFINone; + result_43.zero_padding = 0; + result_43.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_43) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[1]) != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_44; + result_44.type_index = kTVMFFINone; + result_44.zero_padding = 0; + result_44.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_44) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[2]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[2])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_45; + result_45.type_index = kTVMFFINone; + result_45.zero_padding = 0; + result_45.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_45) != 0) { + return -1; + } + } + int32_t condval_10; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_10 = 1; + } else { + condval_10 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[2]); + } + if (condval_10 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_11; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_11 = 1; + } else { + condval_11 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[2]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_11); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_46; + result_46.type_index = kTVMFFINone; + result_46.zero_padding = 0; + result_46.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_46) != 0) { + return -1; + } + } + int32_t condval_12; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_12 = 1; + } else { + condval_12 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[1]); + } + if (condval_12 != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_13; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_13 = 1; + } else { + condval_13 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_13); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_47; + result_47.type_index = kTVMFFINone; + result_47.zero_padding = 0; + result_47.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_47) != 0) { + return -1; + } + } + int32_t condval_14; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_14 = 1; + } else { + condval_14 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[0]); + } + if ((condval_14 != 16384) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_48; + result_48.type_index = kTVMFFINone; + result_48.zero_padding = 0; + result_48.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_48) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)residual)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_49; + result_49.type_index = kTVMFFINone; + result_49.zero_padding = 0; + result_49.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_49) != 0) { + return -1; + } + } + if ((((DLTensor*)residual)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)residual)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_50; + result_50.type_index = kTVMFFINone; + result_50.zero_padding = 0; + result_50.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_50) != 0) { + return -1; + } + } + if ((((DLTensor*)residual)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_51; + result_51.type_index = kTVMFFINone; + result_51.zero_padding = 0; + result_51.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_51) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (residual_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_52; + result_52.type_index = kTVMFFINone; + result_52.zero_padding = 0; + result_52.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_52) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)post_mix)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)post_mix)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)post_mix)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_53; + result_53.type_index = kTVMFFINone; + result_53.zero_padding = 0; + result_53.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_53) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_54; + result_54.type_index = kTVMFFINone; + result_54.zero_padding = 0; + result_54.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_54) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[1]) != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_55; + result_55.type_index = kTVMFFINone; + result_55.zero_padding = 0; + result_55.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_55) != 0) { + return -1; + } + } + int32_t condval_15; + if ((mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides == NULL)) { + condval_15 = 1; + } else { + condval_15 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides)[1]); + } + if (condval_15 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_16; + if ((mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides == NULL)) { + condval_16 = 1; + } else { + condval_16 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_16); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_56; + result_56.type_index = kTVMFFINone; + result_56.zero_padding = 0; + result_56.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_56) != 0) { + return -1; + } + } + int32_t condval_17; + if ((mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides == NULL)) { + condval_17 = 1; + } else { + condval_17 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides)[0]); + } + if ((condval_17 != 4) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_57; + result_57.type_index = kTVMFFINone; + result_57.zero_padding = 0; + result_57.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_57) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)post_mix)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_58; + result_58.type_index = kTVMFFINone; + result_58.zero_padding = 0; + result_58.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_58) != 0) { + return -1; + } + } + if ((((DLTensor*)post_mix)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_59; + result_59.type_index = kTVMFFINone; + result_59.zero_padding = 0; + result_59.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_59) != 0) { + return -1; + } + } + if ((((DLTensor*)post_mix)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_60; + result_60.type_index = kTVMFFINone; + result_60.zero_padding = 0; + result_60.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_60) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (post_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_61; + result_61.type_index = kTVMFFINone; + result_61.zero_padding = 0; + result_61.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_61) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)comb_mix)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)comb_mix)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)comb_mix)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_62; + result_62.type_index = kTVMFFINone; + result_62.zero_padding = 0; + result_62.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_62) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_63; + result_63.type_index = kTVMFFINone; + result_63.zero_padding = 0; + result_63.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_63) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[1]) != 16) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_64; + result_64.type_index = kTVMFFINone; + result_64.zero_padding = 0; + result_64.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_64) != 0) { + return -1; + } + } + int32_t condval_18; + if ((mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides == NULL)) { + condval_18 = 1; + } else { + condval_18 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides)[1]); + } + if (condval_18 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_19; + if ((mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides == NULL)) { + condval_19 = 1; + } else { + condval_19 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_19); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_65; + result_65.type_index = kTVMFFINone; + result_65.zero_padding = 0; + result_65.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_65) != 0) { + return -1; + } + } + int32_t condval_20; + if ((mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides == NULL)) { + condval_20 = 1; + } else { + condval_20 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides)[0]); + } + if ((condval_20 != 16) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_66; + result_66.type_index = kTVMFFINone; + result_66.zero_padding = 0; + result_66.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_66) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)comb_mix)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_67; + result_67.type_index = kTVMFFINone; + result_67.zero_padding = 0; + result_67.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_67) != 0) { + return -1; + } + } + if ((((DLTensor*)comb_mix)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_68; + result_68.type_index = kTVMFFINone; + result_68.zero_padding = 0; + result_68.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_68) != 0) { + return -1; + } + } + if ((((DLTensor*)comb_mix)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_69; + result_69.type_index = kTVMFFINone; + result_69.zero_padding = 0; + result_69.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_69) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (comb_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_70; + result_70.type_index = kTVMFFINone; + result_70.zero_padding = 0; + result_70.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_70) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)layer_input)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)layer_input)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)layer_input)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_71; + result_71.type_index = kTVMFFINone; + result_71.zero_padding = 0; + result_71.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_71) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_72; + result_72.type_index = kTVMFFINone; + result_72.zero_padding = 0; + result_72.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_72) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[1]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_73; + result_73.type_index = kTVMFFINone; + result_73.zero_padding = 0; + result_73.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_73) != 0) { + return -1; + } + } + int32_t condval_21; + if ((mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides == NULL)) { + condval_21 = 1; + } else { + condval_21 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides)[1]); + } + if (condval_21 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_22; + if ((mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides == NULL)) { + condval_22 = 1; + } else { + condval_22 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_22); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_74; + result_74.type_index = kTVMFFINone; + result_74.zero_padding = 0; + result_74.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_74) != 0) { + return -1; + } + } + int32_t condval_23; + if ((mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides == NULL)) { + condval_23 = 1; + } else { + condval_23 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides)[0]); + } + if ((condval_23 != 4096) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_75; + result_75.type_index = kTVMFFINone; + result_75.zero_padding = 0; + result_75.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_75) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)layer_input)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_76; + result_76.type_index = kTVMFFINone; + result_76.zero_padding = 0; + result_76.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_76) != 0) { + return -1; + } + } + if ((((DLTensor*)layer_input)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_77; + result_77.type_index = kTVMFFINone; + result_77.zero_padding = 0; + result_77.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_77) != 0) { + return -1; + } + } + if ((((DLTensor*)layer_input)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_78; + result_78.type_index = kTVMFFINone; + result_78.zero_padding = 0; + result_78.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_78) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (layer_input_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_79; + result_79.type_index = kTVMFFINone; + result_79.zero_padding = 0; + result_79.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_79) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)norm_weight)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)norm_weight)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)norm_weight)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_80; + result_80.type_index = kTVMFFINone; + result_80.zero_padding = 0; + result_80.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_80) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_shape)[0]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_81; + result_81.type_index = kTVMFFINone; + result_81.zero_padding = 0; + result_81.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_81) != 0) { + return -1; + } + } + int32_t condval_24; + if ((mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides == NULL)) { + condval_24 = 1; + } else { + condval_24 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides)[0]); + } + if (condval_24 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_25; + if ((mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides == NULL)) { + condval_25 = 1; + } else { + condval_25 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides)[0]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_25); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_82; + result_82.type_index = kTVMFFINone; + result_82.zero_padding = 0; + result_82.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_82) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)norm_weight)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_83; + result_83.type_index = kTVMFFINone; + result_83.zero_padding = 0; + result_83.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_83) != 0) { + return -1; + } + } + if ((((DLTensor*)norm_weight)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_84; + result_84.type_index = kTVMFFINone; + result_84.zero_padding = 0; + result_84.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_84) != 0) { + return -1; + } + } + if ((((DLTensor*)norm_weight)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_85; + result_85.type_index = kTVMFFINone; + result_85.zero_padding = 0; + result_85.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_85) != 0) { + return -1; + } + } + if (norm_weight_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_86; + result_86.type_index = kTVMFFINone; + result_86.zero_padding = 0; + result_86.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_86) != 0) { + return -1; + } + } + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = ((int64_t)2); + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = ((int64_t)dev_id); + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + if (__tvm_set_device_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_set_device", &__tvm_set_device_packed) != 0) { + return -1; + } + } + TVMFFIAny result_87; + result_87.type_index = kTVMFFINone; + result_87.zero_padding = 0; + result_87.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_set_device_packed, (TVMFFIAny*) stack_ffi_any, 2, &result_87) != 0) { + return -1; + } + if (comb_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = comb_mix_1; + if (gemm_out_mul_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = gemm_out_mul_1; + if (gemm_out_sqrsum_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = gemm_out_sqrsum_1; + if (hc_base_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_ptr) = hc_base_1; + if (hc_scale_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_ptr) = hc_scale_1; + if (layer_input_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_ptr) = layer_input_1; + if (norm_weight_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_ptr) = norm_weight_1; + if (post_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_ptr) = post_mix_1; + if (residual_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_ptr) = residual_1; + (((TVMFFIAny*)stack_ffi_any)[9].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[9].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[9].v_int64) = ((int64_t)num_tokens); + (((TVMFFIAny*)stack_ffi_any)[10].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[10].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[10].v_int64) = ((int64_t)num_tokens); + (((TVMFFIAny*)stack_ffi_any)[11].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[11].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[11].v_int64) = ((int64_t)96); + (((TVMFFIAny*)stack_ffi_any)[12].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[12].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[12].v_int64) = ((int64_t)1); + (((TVMFFIAny*)stack_ffi_any)[13].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[13].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[13].v_int64) = ((int64_t)1); + (((TVMFFIAny*)stack_ffi_any)[14].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[14].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[14].v_int64) = ((int64_t)29040); + (((TVMFFIAny*)stack_ffi_any)[15].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[15].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[15].v_int64) = (int64_t)0; + if (mhc_pre_big_fuse_with_norm_tilelang_kernel_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "mhc_pre_big_fuse_with_norm_tilelang_kernel", &mhc_pre_big_fuse_with_norm_tilelang_kernel_packed) != 0) { + return -1; + } + } + TVMFFIAny result_88; + result_88.type_index = kTVMFFINone; + result_88.zero_padding = 0; + result_88.v_int64 = 0; + if (TVMFFIFunctionCall(mhc_pre_big_fuse_with_norm_tilelang_kernel_packed, (TVMFFIAny*) stack_ffi_any, 15, &result_88) != 0) { + return -1; + } + return 0; +} + +// CodegenC: NOTE: Auto-generated entry function +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_main(void* self, void* args,int num_args, void* result) { + return __tvm_ffi_mhc_pre_big_fuse_with_norm_tilelang(self, args, num_args, result); +} diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/c0ef72219d5280025634d12a15beae51ea48dcaded4066ba7f411defa4b60bff/params.pkl b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/c0ef72219d5280025634d12a15beae51ea48dcaded4066ba7f411defa4b60bff/params.pkl new file mode 100644 index 0000000..c9f15f6 Binary files /dev/null and b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/c0ef72219d5280025634d12a15beae51ea48dcaded4066ba7f411defa4b60bff/params.pkl differ diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/e8bfe015e13b0beed5fbf1df07913214e93cd08d927e1e810f022bb8d28739b0/device_kernel.cu b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/e8bfe015e13b0beed5fbf1df07913214e93cd08d927e1e810f022bb8d28739b0/device_kernel.cu new file mode 100644 index 0000000..83c3db9 --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/e8bfe015e13b0beed5fbf1df07913214e93cd08d927e1e810f022bb8d28739b0/device_kernel.cu @@ -0,0 +1,424 @@ +#include +#include +#include +#include +#include +#include +#include +#ifdef ENABLE_BF16 +#include +#endif + +extern "C" __global__ void mhc_pre_big_fuse_with_norm_tilelang_kernel(float* comb_mix, const float* gemm_out_mul, const float* gemm_out_sqrsum, const float* hc_base, const float* hc_scale, bfloat16_t* layer_input, const bfloat16_t* norm_weight, float* post_mix, const bfloat16_t* residual, int num_tokens); +extern "C" __global__ void __launch_bounds__(96, 1) mhc_pre_big_fuse_with_norm_tilelang_kernel(float* comb_mix, const float* gemm_out_mul, const float* gemm_out_sqrsum, const float* hc_base, const float* hc_scale, bfloat16_t* layer_input, const bfloat16_t* norm_weight, float* post_mix, const bfloat16_t* residual, int num_tokens) { + extern __shared__ __align__(1024) uchar buf_dyn_shmem[]; + float mixes[1]; + float rms[1]; + float cm[1]; + float row_max[1]; + float row_sum[1]; + float col_sum[1]; + float sumsq_per_pos[16]; + float sumsq[1]; + float rsqrt_norm[1]; + float xl[64]; + float ol[16]; + bfloat16_t xs_local_cast[8]; + bfloat16_t xs_local_cast_1[8]; + bfloat16_t xs_local_cast_2[8]; + float w_local[16]; + float ol_1[16]; + bfloat16_t w_shared_local_cast_3[8]; + bfloat16_t output_shared_local_cast_4[8]; + bfloat16_t layer_input_local_cast_5[8]; + bfloat16_t w_shared_local_cast_6[8]; + bfloat16_t output_shared_local_cast_7[8]; + bfloat16_t layer_input_local_cast_8[8]; + bfloat16_t w_shared_local_cast_9[8]; + bfloat16_t output_shared_local_cast_10[8]; + bfloat16_t layer_input_local_cast_11[8]; + mixes[0] = 0x0p+0f/*0.000000e+00*/; + rms[0] = 0x0p+0f/*0.000000e+00*/; + cudaGridDependencySynchronize(); + for (int i_split = 0; i_split < 3; ++i_split) { + rms[0] = (rms[0] + gemm_out_sqrsum[((((int64_t)i_split) * ((int64_t)num_tokens)) + ((int64_t)((int)blockIdx.x)))]); + } + rms[0] = rsqrtf(((rms[0] / 0x1p+14f/*1.638400e+04*/) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + mixes[0] = 0x0p+0f/*0.000000e+00*/; + for (int i_split_1 = 0; i_split_1 < 3; ++i_split_1) { + mixes[0] = (mixes[0] + gemm_out_mul[(((((int64_t)((int)blockIdx.x)) * (int64_t)24) + ((((int64_t)i_split_1) * ((int64_t)num_tokens)) * (int64_t)24)) + (((int64_t)((int)threadIdx.x)) % (int64_t)24))]); + } + mixes[0] = (mixes[0] * rms[0]); + if ((((int)threadIdx.x) / 24) == 0) { + ((float*)buf_dyn_shmem)[(((int)threadIdx.x) % 24)] = mixes[0]; + } + __syncthreads(); + if (((int)threadIdx.x) < 32) { + if (((int)threadIdx.x) < 4) { + post_mix[((((int64_t)((int)blockIdx.x)) * (int64_t)4) + ((int64_t)((int)threadIdx.x)))] = ((0x1p+0f/*1.000000e+00*/ / (0x1p+0f/*1.000000e+00*/ + expf((0x0p+0f/*0.000000e+00*/ - ((((float*)buf_dyn_shmem)[(((int)threadIdx.x) + 4)] * hc_scale[1]) + hc_base[(((int)threadIdx.x) + 4)]))))) * 0x1p+1f/*2.000000e+00*/); + } + cm[0] = ((((float*)buf_dyn_shmem)[((((int)threadIdx.x) & 15) + 8)] * hc_scale[2]) + hc_base[((((int)threadIdx.x) & 15) + 8)]); + row_max[0] = -CUDART_INF_F; + row_max[0] = max(row_max[0], cm[0]); + row_max[0] = tl::AllReduce>::run(row_max[0]); + cm[0] = expf((cm[0] - row_max[0])); + row_sum[0] = 0x0p+0f/*0.000000e+00*/; + row_sum[0] = (row_sum[0] + cm[0]); + row_sum[0] = tl::AllReduce>::run(row_sum[0]); + cm[0] = ((cm[0] / row_sum[0]) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/); + col_sum[0] = 0x0p+0f/*0.000000e+00*/; + col_sum[0] = (col_sum[0] + cm[0]); + col_sum[0] = tl::AllReduce>::run(col_sum[0]); + cm[0] = (cm[0] / (col_sum[0] + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + for (int __1 = 0; __1 < 19; ++__1) { + row_sum[0] = 0x0p+0f/*0.000000e+00*/; + row_sum[0] = (row_sum[0] + cm[0]); + row_sum[0] = tl::AllReduce>::run(row_sum[0]); + cm[0] = (cm[0] / (row_sum[0] + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + col_sum[0] = 0x0p+0f/*0.000000e+00*/; + col_sum[0] = (col_sum[0] + cm[0]); + col_sum[0] = tl::AllReduce>::run(col_sum[0]); + cm[0] = (cm[0] / (col_sum[0] + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + } + if ((((int)threadIdx.x) >> 4) == 0) { + comb_mix[((((int64_t)((int)blockIdx.x)) * (int64_t)16) + (((int64_t)((int)threadIdx.x)) & (int64_t)15))] = cm[0]; + } + } else { + if (((int)threadIdx.x) < 36) { + ((float*)buf_dyn_shmem)[(((int)threadIdx.x) + 7224)] = ((0x1p+0f/*1.000000e+00*/ / (0x1p+0f/*1.000000e+00*/ + expf((0x0p+0f/*0.000000e+00*/ - ((((float*)buf_dyn_shmem)[(((int)threadIdx.x) - 32)] * hc_scale[0]) + hc_base[(((int)threadIdx.x) - 32)]))))) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/); + } + #pragma unroll + for (int i = 0; i < 4; ++i) { + float broadcast_var = 0x0p+0f/*0.000000e+00*/; + *(float4*)(sumsq_per_pos + (i * 4)) = make_float4(broadcast_var, broadcast_var, broadcast_var, broadcast_var); + } + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_1 = 0; i_1 < 8; ++i_1) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i_1 >> 1) * 1024) + (((((i_1 * 64) + ((int)threadIdx.x)) + 96) & 127) * 8)) + 48)])), (&(residual[(((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + ((((int64_t)i_1) >> (int64_t)1) * (int64_t)4096)) + (((((((int64_t)i_1) * (int64_t)64) + ((int64_t)((int)threadIdx.x))) + (int64_t)96) & (int64_t)127) * (int64_t)8))]))); + } + tl::cp_async_commit(); + #pragma unroll + for (int i_2 = 0; i_2 < 8; ++i_2) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i_2 >> 1) * 1024) + (((((i_2 * 64) + ((int)threadIdx.x)) + 96) & 127) * 8)) + 4144)])), (&(residual[((((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + ((((int64_t)i_2) >> (int64_t)1) * (int64_t)4096)) + (((((((int64_t)i_2) * (int64_t)64) + ((int64_t)((int)threadIdx.x))) + (int64_t)96) & (int64_t)127) * (int64_t)8)) + (int64_t)1024)]))); + } + tl::cp_async_commit(); + for (int i0_h = 0; i0_h < 2; ++i0_h) { + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_3 = 0; i_3 < 8; ++i_3) { + *(uint4*)(xs_local_cast + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + ((((i0_h * 4096) + (i_3 * 512)) + (((int)threadIdx.x) * 8)) - 208)); + for (int vec = 0; vec < 2; ++vec) { + float4 __2; + uint2 v_ = *(uint2*)(xs_local_cast + (vec * 4)); + ((float2*)(&__2))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v_))[0]); + ((float2*)(&__2))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v_))[1]); + *(float4*)(xl + ((i_3 * 8) + (vec * 4))) = __2; + } + } + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_4 = 0; i_4 < 8; ++i_4) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i0_h * 4096) + ((i_4 >> 1) * 1024)) + (((((i_4 * 64) + ((int)threadIdx.x)) + 96) & 127) * 8)) + 48)])), (&(residual[(((((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + ((((int64_t)i_4) >> (int64_t)1) * (int64_t)4096)) + (((int64_t)i0_h) * (int64_t)1024)) + (((((((int64_t)i_4) * (int64_t)64) + ((int64_t)((int)threadIdx.x))) + (int64_t)96) & (int64_t)127) * (int64_t)8)) + (int64_t)2048)]))); + } + tl::cp_async_commit(); + #pragma unroll + for (int i_5 = 0; i_5 < 4; ++i_5) { + float broadcast_var_1 = 0x0p+0f/*0.000000e+00*/; + *(float4*)(ol + (i_5 * 4)) = make_float4(broadcast_var_1, broadcast_var_1, broadcast_var_1, broadcast_var_1); + } + tl::__sync_thread_partial<3, 64>(); + for (int i_hc = 0; i_hc < 4; ++i_hc) { + float pre = ((float*)buf_dyn_shmem)[(i_hc + 7256)]; + #pragma unroll + for (int i_6 = 0; i_6 < 16; ++i_6) { + ol[i_6] = (ol[i_6] + (pre * xl[((i_hc * 16) + i_6)])); + } + } + #pragma unroll + for (int i_7 = 0; i_7 < 4; ++i_7) { + float4 __3; + float4 v__1 = *(float4*)(sumsq_per_pos + (i_7 * 4)); + float4 __4; + float4 v__2 = *(float4*)(ol + (i_7 * 4)); + __4.x = (v__2.x*v__2.x); + __4.y = (v__2.y*v__2.y); + __4.z = (v__2.z*v__2.z); + __4.w = (v__2.w*v__2.w); + __3.x = (v__1.x+__4.x); + __3.y = (v__1.y+__4.y); + __3.z = (v__1.z+__4.z); + __3.w = (v__1.w+__4.w); + *(float4*)(sumsq_per_pos + (i_7 * 4)) = __3; + uint2 __5; + float4 v__3 = *(float4*)(ol + (i_7 * 4)); + (reinterpret_cast<__nv_bfloat162*>(&__5))[0] = __float22bfloat162_rn(((float2*)(&v__3))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__5))[1] = __float22bfloat162_rn(((float2*)(&v__3))[1]); + *(uint2*)(((bfloat16_t*)buf_dyn_shmem) + (((((i0_h * 1024) + ((i_7 >> 1) * 512)) + (((int)threadIdx.x) * 8)) + ((i_7 & 1) * 4)) + 7984)) = __5; + } + } + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_8 = 0; i_8 < 8; ++i_8) { + *(uint4*)(xs_local_cast_1 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_8 * 512) + (((int)threadIdx.x) * 8)) - 208)); + for (int vec_1 = 0; vec_1 < 2; ++vec_1) { + float4 __6; + uint2 v__4 = *(uint2*)(xs_local_cast_1 + (vec_1 * 4)); + ((float2*)(&__6))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__4))[0]); + ((float2*)(&__6))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__4))[1]); + *(float4*)(xl + ((i_8 * 8) + (vec_1 * 4))) = __6; + } + } + #pragma unroll + for (int i_9 = 0; i_9 < 4; ++i_9) { + float broadcast_var_2 = 0x0p+0f/*0.000000e+00*/; + *(float4*)(ol + (i_9 * 4)) = make_float4(broadcast_var_2, broadcast_var_2, broadcast_var_2, broadcast_var_2); + } + for (int i_hc_1 = 0; i_hc_1 < 4; ++i_hc_1) { + float pre_1 = ((float*)buf_dyn_shmem)[(i_hc_1 + 7256)]; + #pragma unroll + for (int i_10 = 0; i_10 < 16; ++i_10) { + ol[i_10] = (ol[i_10] + (pre_1 * xl[((i_hc_1 * 16) + i_10)])); + } + } + #pragma unroll + for (int i_11 = 0; i_11 < 4; ++i_11) { + float4 __7; + float4 v__5 = *(float4*)(sumsq_per_pos + (i_11 * 4)); + float4 __8; + float4 v__6 = *(float4*)(ol + (i_11 * 4)); + __8.x = (v__6.x*v__6.x); + __8.y = (v__6.y*v__6.y); + __8.z = (v__6.z*v__6.z); + __8.w = (v__6.w*v__6.w); + __7.x = (v__5.x+__8.x); + __7.y = (v__5.y+__8.y); + __7.z = (v__5.z+__8.z); + __7.w = (v__5.w+__8.w); + *(float4*)(sumsq_per_pos + (i_11 * 4)) = __7; + uint2 __9; + float4 v__7 = *(float4*)(ol + (i_11 * 4)); + (reinterpret_cast<__nv_bfloat162*>(&__9))[0] = __float22bfloat162_rn(((float2*)(&v__7))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__9))[1] = __float22bfloat162_rn(((float2*)(&v__7))[1]); + *(uint2*)(((bfloat16_t*)buf_dyn_shmem) + (((((i_11 >> 1) * 512) + (((int)threadIdx.x) * 8)) + ((i_11 & 1) * 4)) + 10032)) = __9; + } + tl::cp_async_wait<0>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_12 = 0; i_12 < 8; ++i_12) { + *(uint4*)(xs_local_cast_2 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_12 * 512) + (((int)threadIdx.x) * 8)) + 3888)); + for (int vec_2 = 0; vec_2 < 2; ++vec_2) { + float4 __10; + uint2 v__8 = *(uint2*)(xs_local_cast_2 + (vec_2 * 4)); + ((float2*)(&__10))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__8))[0]); + ((float2*)(&__10))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__8))[1]); + *(float4*)(xl + ((i_12 * 8) + (vec_2 * 4))) = __10; + } + } + #pragma unroll + for (int i_13 = 0; i_13 < 4; ++i_13) { + float broadcast_var_3 = 0x0p+0f/*0.000000e+00*/; + *(float4*)(ol + (i_13 * 4)) = make_float4(broadcast_var_3, broadcast_var_3, broadcast_var_3, broadcast_var_3); + } + for (int i_hc_2 = 0; i_hc_2 < 4; ++i_hc_2) { + float pre_2 = ((float*)buf_dyn_shmem)[(i_hc_2 + 7256)]; + #pragma unroll + for (int i_14 = 0; i_14 < 16; ++i_14) { + ol[i_14] = (ol[i_14] + (pre_2 * xl[((i_hc_2 * 16) + i_14)])); + } + } + #pragma unroll + for (int i_15 = 0; i_15 < 4; ++i_15) { + float4 __11; + float4 v__9 = *(float4*)(sumsq_per_pos + (i_15 * 4)); + float4 __12; + float4 v__10 = *(float4*)(ol + (i_15 * 4)); + __12.x = (v__10.x*v__10.x); + __12.y = (v__10.y*v__10.y); + __12.z = (v__10.z*v__10.z); + __12.w = (v__10.w*v__10.w); + __11.x = (v__9.x+__12.x); + __11.y = (v__9.y+__12.y); + __11.z = (v__9.z+__12.z); + __11.w = (v__9.w+__12.w); + *(float4*)(sumsq_per_pos + (i_15 * 4)) = __11; + uint2 __13; + float4 v__11 = *(float4*)(ol + (i_15 * 4)); + (reinterpret_cast<__nv_bfloat162*>(&__13))[0] = __float22bfloat162_rn(((float2*)(&v__11))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__13))[1] = __float22bfloat162_rn(((float2*)(&v__11))[1]); + *(uint2*)(((bfloat16_t*)buf_dyn_shmem) + (((((i_15 >> 1) * 512) + (((int)threadIdx.x) * 8)) + ((i_15 & 1) * 4)) + 11056)) = __13; + } + sumsq[0] = 0x0p+0f/*0.000000e+00*/; + #pragma unroll + for (int rv = 0; rv < 16; ++rv) { + sumsq[0] = (sumsq[0] + sumsq_per_pos[(((rv & 1) * 8) + (rv >> 1))]); + } + tl::__sync_thread_partial<3, 64>(); + sumsq[0] = tl::AllReduce>::run(sumsq[0], (&(((float*)buf_dyn_shmem)[7192]))); + rsqrt_norm[0] = rsqrtf(((sumsq[0] / 0x1p+12f/*4.096000e+03*/) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + #pragma unroll + for (int i_16 = 0; i_16 < 2; ++i_16) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[(((i_16 * 512) + (((int)threadIdx.x) * 8)) + 12080)])), (&(norm_weight[(((i_16 * 512) + (((int)threadIdx.x) * 8)) - 256)]))); + } + tl::cp_async_commit(); + #pragma unroll + for (int i_17 = 0; i_17 < 2; ++i_17) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[(((i_17 * 512) + (((int)threadIdx.x) * 8)) + 13104)])), (&(norm_weight[(((i_17 * 512) + (((int)threadIdx.x) * 8)) + 768)]))); + } + tl::cp_async_commit(); + for (int i0_h_1 = 0; i0_h_1 < 2; ++i0_h_1) { + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_18 = 0; i_18 < 2; ++i_18) { + *(uint4*)(w_shared_local_cast_3 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + ((((i0_h_1 * 1024) + (i_18 * 512)) + (((int)threadIdx.x) * 8)) + 12080)); + for (int vec_3 = 0; vec_3 < 2; ++vec_3) { + float4 __14; + uint2 v__12 = *(uint2*)(w_shared_local_cast_3 + (vec_3 * 4)); + ((float2*)(&__14))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__12))[0]); + ((float2*)(&__14))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__12))[1]); + *(float4*)(w_local + ((i_18 * 8) + (vec_3 * 4))) = __14; + } + } + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_19 = 0; i_19 < 2; ++i_19) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i0_h_1 * 1024) + (i_19 * 512)) + (((int)threadIdx.x) * 8)) + 12080)])), (&(norm_weight[((((i0_h_1 * 1024) + (i_19 * 512)) + (((int)threadIdx.x) * 8)) + 1792)]))); + } + tl::cp_async_commit(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_20 = 0; i_20 < 2; ++i_20) { + *(uint4*)(output_shared_local_cast_4 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + ((((i0_h_1 * 1024) + (i_20 * 512)) + (((int)threadIdx.x) * 8)) + 7984)); + for (int vec_4 = 0; vec_4 < 2; ++vec_4) { + float4 __15; + float4 __16; + float4 __17; + uint2 v__13 = *(uint2*)(output_shared_local_cast_4 + (vec_4 * 4)); + ((float2*)(&__17))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__13))[0]); + ((float2*)(&__17))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__13))[1]); + float4 v__14 = make_float4(rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0]); + __16.x = (__17.x*v__14.x); + __16.y = (__17.y*v__14.y); + __16.z = (__17.z*v__14.z); + __16.w = (__17.w*v__14.w); + float4 v__15 = *(float4*)(w_local + ((i_20 * 8) + (vec_4 * 4))); + __15.x = (__16.x*v__15.x); + __15.y = (__16.y*v__15.y); + __15.z = (__16.z*v__15.z); + __15.w = (__16.w*v__15.w); + *(float4*)(ol_1 + ((i_20 * 8) + (vec_4 * 4))) = __15; + } + } + #pragma unroll + for (int i_21 = 0; i_21 < 2; ++i_21) { + for (int vec_5 = 0; vec_5 < 2; ++vec_5) { + uint2 __18; + float4 v__16 = *(float4*)(ol_1 + ((i_21 * 8) + (vec_5 * 4))); + (reinterpret_cast<__nv_bfloat162*>(&__18))[0] = __float22bfloat162_rn(((float2*)(&v__16))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__18))[1] = __float22bfloat162_rn(((float2*)(&v__16))[1]); + *(uint2*)(layer_input_local_cast_5 + (vec_5 * 4)) = __18; + } + *(uint4*)(layer_input + (((((((int64_t)((int)blockIdx.x)) * (int64_t)4096) + (((int64_t)i0_h_1) * (int64_t)1024)) + (((int64_t)i_21) * (int64_t)512)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8)) - (int64_t)256)) = *(uint4*)(layer_input_local_cast_5 + 0); + } + } + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_22 = 0; i_22 < 2; ++i_22) { + *(uint4*)(w_shared_local_cast_6 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_22 * 512) + (((int)threadIdx.x) * 8)) + 12080)); + for (int vec_6 = 0; vec_6 < 2; ++vec_6) { + float4 __19; + uint2 v__17 = *(uint2*)(w_shared_local_cast_6 + (vec_6 * 4)); + ((float2*)(&__19))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__17))[0]); + ((float2*)(&__19))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__17))[1]); + *(float4*)(w_local + ((i_22 * 8) + (vec_6 * 4))) = __19; + } + } + #pragma unroll + for (int i_23 = 0; i_23 < 2; ++i_23) { + *(uint4*)(output_shared_local_cast_7 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_23 * 512) + (((int)threadIdx.x) * 8)) + 10032)); + for (int vec_7 = 0; vec_7 < 2; ++vec_7) { + float4 __20; + float4 __21; + float4 __22; + uint2 v__18 = *(uint2*)(output_shared_local_cast_7 + (vec_7 * 4)); + ((float2*)(&__22))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__18))[0]); + ((float2*)(&__22))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__18))[1]); + float4 v__19 = make_float4(rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0]); + __21.x = (__22.x*v__19.x); + __21.y = (__22.y*v__19.y); + __21.z = (__22.z*v__19.z); + __21.w = (__22.w*v__19.w); + float4 v__20 = *(float4*)(w_local + ((i_23 * 8) + (vec_7 * 4))); + __20.x = (__21.x*v__20.x); + __20.y = (__21.y*v__20.y); + __20.z = (__21.z*v__20.z); + __20.w = (__21.w*v__20.w); + *(float4*)(ol_1 + ((i_23 * 8) + (vec_7 * 4))) = __20; + } + } + #pragma unroll + for (int i_24 = 0; i_24 < 2; ++i_24) { + for (int vec_8 = 0; vec_8 < 2; ++vec_8) { + uint2 __23; + float4 v__21 = *(float4*)(ol_1 + ((i_24 * 8) + (vec_8 * 4))); + (reinterpret_cast<__nv_bfloat162*>(&__23))[0] = __float22bfloat162_rn(((float2*)(&v__21))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__23))[1] = __float22bfloat162_rn(((float2*)(&v__21))[1]); + *(uint2*)(layer_input_local_cast_8 + (vec_8 * 4)) = __23; + } + *(uint4*)(layer_input + ((((((int64_t)((int)blockIdx.x)) * (int64_t)4096) + (((int64_t)i_24) * (int64_t)512)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8)) + (int64_t)1792)) = *(uint4*)(layer_input_local_cast_8 + 0); + } + tl::cp_async_wait<0>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_25 = 0; i_25 < 2; ++i_25) { + *(uint4*)(w_shared_local_cast_9 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_25 * 512) + (((int)threadIdx.x) * 8)) + 13104)); + for (int vec_9 = 0; vec_9 < 2; ++vec_9) { + float4 __24; + uint2 v__22 = *(uint2*)(w_shared_local_cast_9 + (vec_9 * 4)); + ((float2*)(&__24))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__22))[0]); + ((float2*)(&__24))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__22))[1]); + *(float4*)(w_local + ((i_25 * 8) + (vec_9 * 4))) = __24; + } + } + #pragma unroll + for (int i_26 = 0; i_26 < 2; ++i_26) { + *(uint4*)(output_shared_local_cast_10 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_26 * 512) + (((int)threadIdx.x) * 8)) + 11056)); + for (int vec_10 = 0; vec_10 < 2; ++vec_10) { + float4 __25; + float4 __26; + float4 __27; + uint2 v__23 = *(uint2*)(output_shared_local_cast_10 + (vec_10 * 4)); + ((float2*)(&__27))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__23))[0]); + ((float2*)(&__27))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__23))[1]); + float4 v__24 = make_float4(rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0]); + __26.x = (__27.x*v__24.x); + __26.y = (__27.y*v__24.y); + __26.z = (__27.z*v__24.z); + __26.w = (__27.w*v__24.w); + float4 v__25 = *(float4*)(w_local + ((i_26 * 8) + (vec_10 * 4))); + __25.x = (__26.x*v__25.x); + __25.y = (__26.y*v__25.y); + __25.z = (__26.z*v__25.z); + __25.w = (__26.w*v__25.w); + *(float4*)(ol_1 + ((i_26 * 8) + (vec_10 * 4))) = __25; + } + } + #pragma unroll + for (int i_27 = 0; i_27 < 2; ++i_27) { + for (int vec_11 = 0; vec_11 < 2; ++vec_11) { + uint2 __28; + float4 v__26 = *(float4*)(ol_1 + ((i_27 * 8) + (vec_11 * 4))); + (reinterpret_cast<__nv_bfloat162*>(&__28))[0] = __float22bfloat162_rn(((float2*)(&v__26))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__28))[1] = __float22bfloat162_rn(((float2*)(&v__26))[1]); + *(uint2*)(layer_input_local_cast_11 + (vec_11 * 4)) = __28; + } + *(uint4*)(layer_input + ((((((int64_t)((int)blockIdx.x)) * (int64_t)4096) + (((int64_t)i_27) * (int64_t)512)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8)) + (int64_t)2816)) = *(uint4*)(layer_input_local_cast_11 + 0); + } + } + cudaTriggerProgrammaticLaunchCompletion(); +} + diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/e8bfe015e13b0beed5fbf1df07913214e93cd08d927e1e810f022bb8d28739b0/host_kernel.cu b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/e8bfe015e13b0beed5fbf1df07913214e93cd08d927e1e810f022bb8d28739b0/host_kernel.cu new file mode 100644 index 0000000..029d209 --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/e8bfe015e13b0beed5fbf1df07913214e93cd08d927e1e810f022bb8d28739b0/host_kernel.cu @@ -0,0 +1,3359 @@ +// tilelang target: c -keys=cpu +#define TVM_EXPORTS +#include "tvm/runtime/base.h" +#include "tvm/runtime/c_backend_api.h" +#include "tvm/ffi/c_api.h" +#include +#include +#include +#ifdef __OBJC__ +#include "tvm/runtime/device_api.h" +#include "tvm/ffi/function.h" +#include +#include +#include +#endif +void* __tvm_ffi__library_ctx = NULL; +static void* __tvm_error_ndim_mismatch_packed = NULL; +static void* __tvm_error_dtype_mismatch_packed = NULL; +static void* __tvm_error_expect_eq_packed = NULL; +static void* __tvm_error_constraint_violation_packed = NULL; +static void* __tvm_error_byte_offset_mismatch_packed = NULL; +static void* __tvm_error_device_type_mismatch_packed = NULL; +static void* __tvm_error_null_ptr_packed = NULL; +static void* __tvm_set_device_packed = NULL; +static void* mhc_pre_big_fuse_with_norm_tilelang_kernel_packed = NULL; +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_mhc_pre_big_fuse_with_norm_tilelang(void* self_handle, void* args, int32_t num_args, void* result); +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_mhc_pre_big_fuse_with_norm_tilelang(void* self_handle, void* args, int32_t num_args, void* result) { + __attribute__((aligned(64))) TVMFFIAny stack[16]; + void* stack_ffi_any = stack; + if (!((num_args == 9))) { + char __tvm_assert_msg_buf[512]; + snprintf(__tvm_assert_msg_buf, 512, "%s; expected: %lld, got: %lld", "mhc_pre_big_fuse_with_norm_tilelang: num_args should be 9", (long long)(num_args), (long long)(9)); + TVMFFIErrorSetRaisedFromCStr("RuntimeError", __tvm_assert_msg_buf); + return -1; + } + if (!(!(args == NULL))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang: args pointer is NULL"); + return -1; + } + int32_t gemm_out_mul_type_index = (((TVMFFIAny*)args)[0].type_index); + if (!(((((gemm_out_mul_type_index == 0) || (gemm_out_mul_type_index == 4)) || (gemm_out_mul_type_index == 7)) || (64 <= gemm_out_mul_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input gemm_out_mul expected pointer or tensor handle"); + return -1; + } + int32_t gemm_out_sqrsum_type_index = (((TVMFFIAny*)args)[1].type_index); + if (!(((((gemm_out_sqrsum_type_index == 0) || (gemm_out_sqrsum_type_index == 4)) || (gemm_out_sqrsum_type_index == 7)) || (64 <= gemm_out_sqrsum_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input gemm_out_sqrsum expected pointer or tensor handle"); + return -1; + } + int32_t hc_scale_type_index = (((TVMFFIAny*)args)[2].type_index); + if (!(((((hc_scale_type_index == 0) || (hc_scale_type_index == 4)) || (hc_scale_type_index == 7)) || (64 <= hc_scale_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input hc_scale expected pointer or tensor handle"); + return -1; + } + int32_t hc_base_type_index = (((TVMFFIAny*)args)[3].type_index); + if (!(((((hc_base_type_index == 0) || (hc_base_type_index == 4)) || (hc_base_type_index == 7)) || (64 <= hc_base_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input hc_base expected pointer or tensor handle"); + return -1; + } + int32_t residual_type_index = (((TVMFFIAny*)args)[4].type_index); + if (!(((((residual_type_index == 0) || (residual_type_index == 4)) || (residual_type_index == 7)) || (64 <= residual_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input residual expected pointer or tensor handle"); + return -1; + } + int32_t post_mix_type_index = (((TVMFFIAny*)args)[5].type_index); + if (!(((((post_mix_type_index == 0) || (post_mix_type_index == 4)) || (post_mix_type_index == 7)) || (64 <= post_mix_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input post_mix expected pointer or tensor handle"); + return -1; + } + int32_t comb_mix_type_index = (((TVMFFIAny*)args)[6].type_index); + if (!(((((comb_mix_type_index == 0) || (comb_mix_type_index == 4)) || (comb_mix_type_index == 7)) || (64 <= comb_mix_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input comb_mix expected pointer or tensor handle"); + return -1; + } + int32_t layer_input_type_index = (((TVMFFIAny*)args)[7].type_index); + if (!(((((layer_input_type_index == 0) || (layer_input_type_index == 4)) || (layer_input_type_index == 7)) || (64 <= layer_input_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input layer_input expected pointer or tensor handle"); + return -1; + } + int32_t norm_weight_type_index = (((TVMFFIAny*)args)[8].type_index); + if (!(((((norm_weight_type_index == 0) || (norm_weight_type_index == 4)) || (norm_weight_type_index == 7)) || (64 <= norm_weight_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input norm_weight expected pointer or tensor handle"); + return -1; + } + void* gemm_out_mul = ((gemm_out_mul_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[0].v_ptr) + 24)) : (((TVMFFIAny*)args)[0].v_ptr)); + void* gemm_out_sqrsum = ((gemm_out_sqrsum_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[1].v_ptr) + 24)) : (((TVMFFIAny*)args)[1].v_ptr)); + void* hc_scale = ((hc_scale_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[2].v_ptr) + 24)) : (((TVMFFIAny*)args)[2].v_ptr)); + void* hc_base = ((hc_base_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[3].v_ptr) + 24)) : (((TVMFFIAny*)args)[3].v_ptr)); + void* residual = ((residual_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[4].v_ptr) + 24)) : (((TVMFFIAny*)args)[4].v_ptr)); + void* post_mix = ((post_mix_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[5].v_ptr) + 24)) : (((TVMFFIAny*)args)[5].v_ptr)); + void* comb_mix = ((comb_mix_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[6].v_ptr) + 24)) : (((TVMFFIAny*)args)[6].v_ptr)); + void* layer_input = ((layer_input_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[7].v_ptr) + 24)) : (((TVMFFIAny*)args)[7].v_ptr)); + void* norm_weight = ((norm_weight_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[8].v_ptr) + 24)) : (((TVMFFIAny*)args)[8].v_ptr)); + bool mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_is_null = (gemm_out_mul == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.gemm_out_mul is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_is_null = (gemm_out_sqrsum == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.gemm_out_sqrsum is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_hc_scale_is_null = (hc_scale == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_hc_scale_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.hc_scale is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_hc_base_is_null = (hc_base == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_hc_base_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.hc_base is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_residual_is_null = (residual == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_residual_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.residual is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_post_mix_is_null = (post_mix == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_post_mix_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.post_mix is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_comb_mix_is_null = (comb_mix == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_comb_mix_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.comb_mix is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_layer_input_is_null = (layer_input == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_layer_input_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.layer_input is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_norm_weight_is_null = (norm_weight == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_norm_weight_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.norm_weight is expected to have non-NULL pointer"); + return -1; + } + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape = (((DLTensor*)gemm_out_mul)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape = (((DLTensor*)gemm_out_sqrsum)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_hc_scale_shape = (((DLTensor*)hc_scale)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_hc_base_shape = (((DLTensor*)hc_base)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_residual_shape = (((DLTensor*)residual)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape = (((DLTensor*)post_mix)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape = (((DLTensor*)comb_mix)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape = (((DLTensor*)layer_input)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_norm_weight_shape = (((DLTensor*)norm_weight)[0].shape); + if ((((DLTensor*)gemm_out_mul)[0].ndim) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_1; + result_1.type_index = kTVMFFINone; + result_1.zero_padding = 0; + result_1.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_1) != 0) { + return -1; + } + } + if (!((bool)1)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "Symbolic shape variable num_tokens requires at least one non-null buffer among: mhc_pre_big_fuse_with_norm_tilelang.gemm_out_mul, mhc_pre_big_fuse_with_norm_tilelang.gemm_out_sqrsum, mhc_pre_big_fuse_with_norm_tilelang.residual, mhc_pre_big_fuse_with_norm_tilelang.post_mix, mhc_pre_big_fuse_with_norm_tilelang.comb_mix, mhc_pre_big_fuse_with_norm_tilelang.layer_input"); + return -1; + } + int32_t num_tokens = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]); + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides = (((DLTensor*)gemm_out_mul)[0].strides); + int32_t dev_id = (((DLTensor*)gemm_out_mul)[0].device.device_id); + void* gemm_out_mul_1 = (((DLTensor*)gemm_out_mul)[0].data); + if ((((DLTensor*)gemm_out_sqrsum)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_2; + result_2.type_index = kTVMFFINone; + result_2.zero_padding = 0; + result_2.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_2) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides = (((DLTensor*)gemm_out_sqrsum)[0].strides); + void* gemm_out_sqrsum_1 = (((DLTensor*)gemm_out_sqrsum)[0].data); + if ((((DLTensor*)hc_scale)[0].ndim) != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_3; + result_3.type_index = kTVMFFINone; + result_3.zero_padding = 0; + result_3.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_3) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides = (((DLTensor*)hc_scale)[0].strides); + void* hc_scale_1 = (((DLTensor*)hc_scale)[0].data); + if ((((DLTensor*)hc_base)[0].ndim) != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_4; + result_4.type_index = kTVMFFINone; + result_4.zero_padding = 0; + result_4.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_4) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides = (((DLTensor*)hc_base)[0].strides); + void* hc_base_1 = (((DLTensor*)hc_base)[0].data); + if ((((DLTensor*)residual)[0].ndim) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_5; + result_5.type_index = kTVMFFINone; + result_5.zero_padding = 0; + result_5.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_5) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_residual_strides = (((DLTensor*)residual)[0].strides); + void* residual_1 = (((DLTensor*)residual)[0].data); + if ((((DLTensor*)post_mix)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_6; + result_6.type_index = kTVMFFINone; + result_6.zero_padding = 0; + result_6.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_6) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides = (((DLTensor*)post_mix)[0].strides); + void* post_mix_1 = (((DLTensor*)post_mix)[0].data); + if ((((DLTensor*)comb_mix)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_7; + result_7.type_index = kTVMFFINone; + result_7.zero_padding = 0; + result_7.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_7) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides = (((DLTensor*)comb_mix)[0].strides); + void* comb_mix_1 = (((DLTensor*)comb_mix)[0].data); + if ((((DLTensor*)layer_input)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_8; + result_8.type_index = kTVMFFINone; + result_8.zero_padding = 0; + result_8.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_8) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides = (((DLTensor*)layer_input)[0].strides); + void* layer_input_1 = (((DLTensor*)layer_input)[0].data); + if ((((DLTensor*)norm_weight)[0].ndim) != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_9; + result_9.type_index = kTVMFFINone; + result_9.zero_padding = 0; + result_9.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_9) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides = (((DLTensor*)norm_weight)[0].strides); + void* norm_weight_1 = (((DLTensor*)norm_weight)[0].data); + if ((((((DLTensor*)gemm_out_mul)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)gemm_out_mul)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)gemm_out_mul)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_10; + result_10.type_index = kTVMFFINone; + result_10.zero_padding = 0; + result_10.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_10) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[0]) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_11; + result_11.type_index = kTVMFFINone; + result_11.zero_padding = 0; + result_11.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_11) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[2]) != 24) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)24; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[2])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_12; + result_12.type_index = kTVMFFINone; + result_12.zero_padding = 0; + result_12.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_12) != 0) { + return -1; + } + } + int32_t condval; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval = 1; + } else { + condval = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[2]); + } + if (condval != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_1; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval_1 = 1; + } else { + condval_1 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[2]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_1); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_13; + result_13.type_index = kTVMFFINone; + result_13.zero_padding = 0; + result_13.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_13) != 0) { + return -1; + } + } + int32_t condval_2; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval_2 = 1; + } else { + condval_2 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[1]); + } + if ((condval_2 != 24) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_14; + result_14.type_index = kTVMFFINone; + result_14.zero_padding = 0; + result_14.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_14) != 0) { + return -1; + } + } + int32_t condval_3; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval_3 = 1; + } else { + condval_3 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[0]); + } + if (((num_tokens * 24) != condval_3) && (num_tokens != 0)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_15; + result_15.type_index = kTVMFFINone; + result_15.zero_padding = 0; + result_15.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_15) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)gemm_out_mul)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_16; + result_16.type_index = kTVMFFINone; + result_16.zero_padding = 0; + result_16.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_16) != 0) { + return -1; + } + } + if ((((DLTensor*)gemm_out_mul)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_17; + result_17.type_index = kTVMFFINone; + result_17.zero_padding = 0; + result_17.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_17) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (gemm_out_mul_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_18; + result_18.type_index = kTVMFFINone; + result_18.zero_padding = 0; + result_18.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_18) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)gemm_out_sqrsum)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)gemm_out_sqrsum)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)gemm_out_sqrsum)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_19; + result_19.type_index = kTVMFFINone; + result_19.zero_padding = 0; + result_19.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_19) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[0]) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_20; + result_20.type_index = kTVMFFINone; + result_20.zero_padding = 0; + result_20.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_20) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[1])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_21; + result_21.type_index = kTVMFFINone; + result_21.zero_padding = 0; + result_21.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_21) != 0) { + return -1; + } + } + int32_t condval_4; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides == NULL)) { + condval_4 = 1; + } else { + condval_4 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides)[1]); + } + if ((condval_4 != 1) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_22; + result_22.type_index = kTVMFFINone; + result_22.zero_padding = 0; + result_22.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_22) != 0) { + return -1; + } + } + int32_t condval_5; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides == NULL)) { + condval_5 = 1; + } else { + condval_5 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides)[0]); + } + if ((((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != condval_5) && (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != 0)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_23; + result_23.type_index = kTVMFFINone; + result_23.zero_padding = 0; + result_23.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_23) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)gemm_out_sqrsum)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_24; + result_24.type_index = kTVMFFINone; + result_24.zero_padding = 0; + result_24.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_24) != 0) { + return -1; + } + } + if ((((DLTensor*)gemm_out_sqrsum)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_25; + result_25.type_index = kTVMFFINone; + result_25.zero_padding = 0; + result_25.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_25) != 0) { + return -1; + } + } + if ((((DLTensor*)gemm_out_sqrsum)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_26; + result_26.type_index = kTVMFFINone; + result_26.zero_padding = 0; + result_26.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_26) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (gemm_out_sqrsum_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_27; + result_27.type_index = kTVMFFINone; + result_27.zero_padding = 0; + result_27.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_27) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)hc_scale)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)hc_scale)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)hc_scale)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_28; + result_28.type_index = kTVMFFINone; + result_28.zero_padding = 0; + result_28.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_28) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_shape)[0]) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_29; + result_29.type_index = kTVMFFINone; + result_29.zero_padding = 0; + result_29.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_29) != 0) { + return -1; + } + } + int32_t condval_6; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides == NULL)) { + condval_6 = 1; + } else { + condval_6 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides)[0]); + } + if (condval_6 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_7; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides == NULL)) { + condval_7 = 1; + } else { + condval_7 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides)[0]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_7); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_30; + result_30.type_index = kTVMFFINone; + result_30.zero_padding = 0; + result_30.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_30) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)hc_scale)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_31; + result_31.type_index = kTVMFFINone; + result_31.zero_padding = 0; + result_31.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_31) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_scale)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_32; + result_32.type_index = kTVMFFINone; + result_32.zero_padding = 0; + result_32.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_32) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_scale)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_33; + result_33.type_index = kTVMFFINone; + result_33.zero_padding = 0; + result_33.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_33) != 0) { + return -1; + } + } + if (hc_scale_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_34; + result_34.type_index = kTVMFFINone; + result_34.zero_padding = 0; + result_34.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_34) != 0) { + return -1; + } + } + if ((((((DLTensor*)hc_base)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)hc_base)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)hc_base)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_35; + result_35.type_index = kTVMFFINone; + result_35.zero_padding = 0; + result_35.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_35) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_shape)[0]) != 24) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)24; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_36; + result_36.type_index = kTVMFFINone; + result_36.zero_padding = 0; + result_36.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_36) != 0) { + return -1; + } + } + int32_t condval_8; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides == NULL)) { + condval_8 = 1; + } else { + condval_8 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides)[0]); + } + if (condval_8 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_9; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides == NULL)) { + condval_9 = 1; + } else { + condval_9 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides)[0]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_9); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_37; + result_37.type_index = kTVMFFINone; + result_37.zero_padding = 0; + result_37.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_37) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)hc_base)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_38; + result_38.type_index = kTVMFFINone; + result_38.zero_padding = 0; + result_38.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_38) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_base)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_39; + result_39.type_index = kTVMFFINone; + result_39.zero_padding = 0; + result_39.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_39) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_base)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_40; + result_40.type_index = kTVMFFINone; + result_40.zero_padding = 0; + result_40.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_40) != 0) { + return -1; + } + } + if (hc_base_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_41; + result_41.type_index = kTVMFFINone; + result_41.zero_padding = 0; + result_41.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_41) != 0) { + return -1; + } + } + if ((((((DLTensor*)residual)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)residual)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)residual)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)residual)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)residual)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_42; + result_42.type_index = kTVMFFINone; + result_42.zero_padding = 0; + result_42.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_42) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_43; + result_43.type_index = kTVMFFINone; + result_43.zero_padding = 0; + result_43.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_43) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[1]) != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_44; + result_44.type_index = kTVMFFINone; + result_44.zero_padding = 0; + result_44.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_44) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[2]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[2])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_45; + result_45.type_index = kTVMFFINone; + result_45.zero_padding = 0; + result_45.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_45) != 0) { + return -1; + } + } + int32_t condval_10; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_10 = 1; + } else { + condval_10 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[2]); + } + if (condval_10 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_11; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_11 = 1; + } else { + condval_11 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[2]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_11); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_46; + result_46.type_index = kTVMFFINone; + result_46.zero_padding = 0; + result_46.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_46) != 0) { + return -1; + } + } + int32_t condval_12; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_12 = 1; + } else { + condval_12 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[1]); + } + if (condval_12 != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_13; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_13 = 1; + } else { + condval_13 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_13); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_47; + result_47.type_index = kTVMFFINone; + result_47.zero_padding = 0; + result_47.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_47) != 0) { + return -1; + } + } + int32_t condval_14; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_14 = 1; + } else { + condval_14 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[0]); + } + if ((condval_14 != 16384) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_48; + result_48.type_index = kTVMFFINone; + result_48.zero_padding = 0; + result_48.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_48) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)residual)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_49; + result_49.type_index = kTVMFFINone; + result_49.zero_padding = 0; + result_49.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_49) != 0) { + return -1; + } + } + if ((((DLTensor*)residual)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)residual)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_50; + result_50.type_index = kTVMFFINone; + result_50.zero_padding = 0; + result_50.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_50) != 0) { + return -1; + } + } + if ((((DLTensor*)residual)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_51; + result_51.type_index = kTVMFFINone; + result_51.zero_padding = 0; + result_51.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_51) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (residual_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_52; + result_52.type_index = kTVMFFINone; + result_52.zero_padding = 0; + result_52.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_52) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)post_mix)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)post_mix)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)post_mix)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_53; + result_53.type_index = kTVMFFINone; + result_53.zero_padding = 0; + result_53.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_53) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_54; + result_54.type_index = kTVMFFINone; + result_54.zero_padding = 0; + result_54.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_54) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[1]) != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_55; + result_55.type_index = kTVMFFINone; + result_55.zero_padding = 0; + result_55.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_55) != 0) { + return -1; + } + } + int32_t condval_15; + if ((mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides == NULL)) { + condval_15 = 1; + } else { + condval_15 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides)[1]); + } + if (condval_15 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_16; + if ((mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides == NULL)) { + condval_16 = 1; + } else { + condval_16 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_16); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_56; + result_56.type_index = kTVMFFINone; + result_56.zero_padding = 0; + result_56.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_56) != 0) { + return -1; + } + } + int32_t condval_17; + if ((mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides == NULL)) { + condval_17 = 1; + } else { + condval_17 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides)[0]); + } + if ((condval_17 != 4) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_57; + result_57.type_index = kTVMFFINone; + result_57.zero_padding = 0; + result_57.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_57) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)post_mix)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_58; + result_58.type_index = kTVMFFINone; + result_58.zero_padding = 0; + result_58.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_58) != 0) { + return -1; + } + } + if ((((DLTensor*)post_mix)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_59; + result_59.type_index = kTVMFFINone; + result_59.zero_padding = 0; + result_59.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_59) != 0) { + return -1; + } + } + if ((((DLTensor*)post_mix)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_60; + result_60.type_index = kTVMFFINone; + result_60.zero_padding = 0; + result_60.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_60) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (post_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_61; + result_61.type_index = kTVMFFINone; + result_61.zero_padding = 0; + result_61.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_61) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)comb_mix)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)comb_mix)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)comb_mix)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_62; + result_62.type_index = kTVMFFINone; + result_62.zero_padding = 0; + result_62.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_62) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_63; + result_63.type_index = kTVMFFINone; + result_63.zero_padding = 0; + result_63.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_63) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[1]) != 16) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_64; + result_64.type_index = kTVMFFINone; + result_64.zero_padding = 0; + result_64.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_64) != 0) { + return -1; + } + } + int32_t condval_18; + if ((mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides == NULL)) { + condval_18 = 1; + } else { + condval_18 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides)[1]); + } + if (condval_18 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_19; + if ((mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides == NULL)) { + condval_19 = 1; + } else { + condval_19 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_19); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_65; + result_65.type_index = kTVMFFINone; + result_65.zero_padding = 0; + result_65.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_65) != 0) { + return -1; + } + } + int32_t condval_20; + if ((mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides == NULL)) { + condval_20 = 1; + } else { + condval_20 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides)[0]); + } + if ((condval_20 != 16) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_66; + result_66.type_index = kTVMFFINone; + result_66.zero_padding = 0; + result_66.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_66) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)comb_mix)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_67; + result_67.type_index = kTVMFFINone; + result_67.zero_padding = 0; + result_67.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_67) != 0) { + return -1; + } + } + if ((((DLTensor*)comb_mix)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_68; + result_68.type_index = kTVMFFINone; + result_68.zero_padding = 0; + result_68.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_68) != 0) { + return -1; + } + } + if ((((DLTensor*)comb_mix)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_69; + result_69.type_index = kTVMFFINone; + result_69.zero_padding = 0; + result_69.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_69) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (comb_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_70; + result_70.type_index = kTVMFFINone; + result_70.zero_padding = 0; + result_70.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_70) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)layer_input)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)layer_input)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)layer_input)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_71; + result_71.type_index = kTVMFFINone; + result_71.zero_padding = 0; + result_71.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_71) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_72; + result_72.type_index = kTVMFFINone; + result_72.zero_padding = 0; + result_72.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_72) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[1]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_73; + result_73.type_index = kTVMFFINone; + result_73.zero_padding = 0; + result_73.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_73) != 0) { + return -1; + } + } + int32_t condval_21; + if ((mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides == NULL)) { + condval_21 = 1; + } else { + condval_21 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides)[1]); + } + if (condval_21 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_22; + if ((mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides == NULL)) { + condval_22 = 1; + } else { + condval_22 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_22); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_74; + result_74.type_index = kTVMFFINone; + result_74.zero_padding = 0; + result_74.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_74) != 0) { + return -1; + } + } + int32_t condval_23; + if ((mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides == NULL)) { + condval_23 = 1; + } else { + condval_23 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides)[0]); + } + if ((condval_23 != 4096) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_75; + result_75.type_index = kTVMFFINone; + result_75.zero_padding = 0; + result_75.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_75) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)layer_input)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_76; + result_76.type_index = kTVMFFINone; + result_76.zero_padding = 0; + result_76.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_76) != 0) { + return -1; + } + } + if ((((DLTensor*)layer_input)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_77; + result_77.type_index = kTVMFFINone; + result_77.zero_padding = 0; + result_77.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_77) != 0) { + return -1; + } + } + if ((((DLTensor*)layer_input)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_78; + result_78.type_index = kTVMFFINone; + result_78.zero_padding = 0; + result_78.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_78) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (layer_input_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_79; + result_79.type_index = kTVMFFINone; + result_79.zero_padding = 0; + result_79.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_79) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)norm_weight)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)norm_weight)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)norm_weight)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_80; + result_80.type_index = kTVMFFINone; + result_80.zero_padding = 0; + result_80.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_80) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_shape)[0]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_81; + result_81.type_index = kTVMFFINone; + result_81.zero_padding = 0; + result_81.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_81) != 0) { + return -1; + } + } + int32_t condval_24; + if ((mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides == NULL)) { + condval_24 = 1; + } else { + condval_24 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides)[0]); + } + if (condval_24 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_25; + if ((mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides == NULL)) { + condval_25 = 1; + } else { + condval_25 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides)[0]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_25); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_82; + result_82.type_index = kTVMFFINone; + result_82.zero_padding = 0; + result_82.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_82) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)norm_weight)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_83; + result_83.type_index = kTVMFFINone; + result_83.zero_padding = 0; + result_83.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_83) != 0) { + return -1; + } + } + if ((((DLTensor*)norm_weight)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_84; + result_84.type_index = kTVMFFINone; + result_84.zero_padding = 0; + result_84.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_84) != 0) { + return -1; + } + } + if ((((DLTensor*)norm_weight)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_85; + result_85.type_index = kTVMFFINone; + result_85.zero_padding = 0; + result_85.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_85) != 0) { + return -1; + } + } + if (norm_weight_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_86; + result_86.type_index = kTVMFFINone; + result_86.zero_padding = 0; + result_86.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_86) != 0) { + return -1; + } + } + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = ((int64_t)2); + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = ((int64_t)dev_id); + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + if (__tvm_set_device_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_set_device", &__tvm_set_device_packed) != 0) { + return -1; + } + } + TVMFFIAny result_87; + result_87.type_index = kTVMFFINone; + result_87.zero_padding = 0; + result_87.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_set_device_packed, (TVMFFIAny*) stack_ffi_any, 2, &result_87) != 0) { + return -1; + } + if (comb_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = comb_mix_1; + if (gemm_out_mul_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = gemm_out_mul_1; + if (gemm_out_sqrsum_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = gemm_out_sqrsum_1; + if (hc_base_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_ptr) = hc_base_1; + if (hc_scale_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_ptr) = hc_scale_1; + if (layer_input_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_ptr) = layer_input_1; + if (norm_weight_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_ptr) = norm_weight_1; + if (post_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_ptr) = post_mix_1; + if (residual_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_ptr) = residual_1; + (((TVMFFIAny*)stack_ffi_any)[9].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[9].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[9].v_int64) = ((int64_t)num_tokens); + (((TVMFFIAny*)stack_ffi_any)[10].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[10].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[10].v_int64) = ((int64_t)num_tokens); + (((TVMFFIAny*)stack_ffi_any)[11].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[11].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[11].v_int64) = ((int64_t)96); + (((TVMFFIAny*)stack_ffi_any)[12].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[12].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[12].v_int64) = ((int64_t)1); + (((TVMFFIAny*)stack_ffi_any)[13].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[13].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[13].v_int64) = ((int64_t)1); + (((TVMFFIAny*)stack_ffi_any)[14].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[14].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[14].v_int64) = ((int64_t)29040); + (((TVMFFIAny*)stack_ffi_any)[15].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[15].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[15].v_int64) = (int64_t)0; + if (mhc_pre_big_fuse_with_norm_tilelang_kernel_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "mhc_pre_big_fuse_with_norm_tilelang_kernel", &mhc_pre_big_fuse_with_norm_tilelang_kernel_packed) != 0) { + return -1; + } + } + TVMFFIAny result_88; + result_88.type_index = kTVMFFINone; + result_88.zero_padding = 0; + result_88.v_int64 = 0; + if (TVMFFIFunctionCall(mhc_pre_big_fuse_with_norm_tilelang_kernel_packed, (TVMFFIAny*) stack_ffi_any, 15, &result_88) != 0) { + return -1; + } + return 0; +} + +// CodegenC: NOTE: Auto-generated entry function +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_main(void* self, void* args,int num_args, void* result) { + return __tvm_ffi_mhc_pre_big_fuse_with_norm_tilelang(self, args, num_args, result); +} diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/e8bfe015e13b0beed5fbf1df07913214e93cd08d927e1e810f022bb8d28739b0/params.pkl b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/e8bfe015e13b0beed5fbf1df07913214e93cd08d927e1e810f022bb8d28739b0/params.pkl new file mode 100644 index 0000000..b0a9721 Binary files /dev/null and b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/e8bfe015e13b0beed5fbf1df07913214e93cd08d927e1e810f022bb8d28739b0/params.pkl differ diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/ee551f0fd55a5f344ee5ec2ee5aa79c7656eb4c9efbd0c4a7c2d3107c1e82478/device_kernel.cu b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/ee551f0fd55a5f344ee5ec2ee5aa79c7656eb4c9efbd0c4a7c2d3107c1e82478/device_kernel.cu new file mode 100644 index 0000000..898a970 --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/ee551f0fd55a5f344ee5ec2ee5aa79c7656eb4c9efbd0c4a7c2d3107c1e82478/device_kernel.cu @@ -0,0 +1,424 @@ +#include +#include +#include +#include +#include +#include +#include +#ifdef ENABLE_BF16 +#include +#endif + +extern "C" __global__ void mhc_pre_big_fuse_with_norm_tilelang_kernel(float* comb_mix, const float* gemm_out_mul, const float* gemm_out_sqrsum, const float* hc_base, const float* hc_scale, bfloat16_t* layer_input, const bfloat16_t* norm_weight, float* post_mix, const bfloat16_t* residual, int num_tokens); +extern "C" __global__ void __launch_bounds__(96, 1) mhc_pre_big_fuse_with_norm_tilelang_kernel(float* comb_mix, const float* gemm_out_mul, const float* gemm_out_sqrsum, const float* hc_base, const float* hc_scale, bfloat16_t* layer_input, const bfloat16_t* norm_weight, float* post_mix, const bfloat16_t* residual, int num_tokens) { + extern __shared__ __align__(1024) uchar buf_dyn_shmem[]; + float mixes[1]; + float rms[1]; + float cm[1]; + float row_max[1]; + float row_sum[1]; + float col_sum[1]; + float sumsq_per_pos[16]; + float sumsq[1]; + float rsqrt_norm[1]; + float xl[64]; + float ol[16]; + bfloat16_t xs_local_cast[8]; + bfloat16_t xs_local_cast_1[8]; + bfloat16_t xs_local_cast_2[8]; + float w_local[16]; + float ol_1[16]; + bfloat16_t w_shared_local_cast_3[8]; + bfloat16_t output_shared_local_cast_4[8]; + bfloat16_t layer_input_local_cast_5[8]; + bfloat16_t w_shared_local_cast_6[8]; + bfloat16_t output_shared_local_cast_7[8]; + bfloat16_t layer_input_local_cast_8[8]; + bfloat16_t w_shared_local_cast_9[8]; + bfloat16_t output_shared_local_cast_10[8]; + bfloat16_t layer_input_local_cast_11[8]; + mixes[0] = 0x0p+0f/*0.000000e+00*/; + rms[0] = 0x0p+0f/*0.000000e+00*/; + cudaGridDependencySynchronize(); + for (int i_split = 0; i_split < 7; ++i_split) { + rms[0] = (rms[0] + gemm_out_sqrsum[((((int64_t)i_split) * ((int64_t)num_tokens)) + ((int64_t)((int)blockIdx.x)))]); + } + rms[0] = rsqrtf(((rms[0] / 0x1p+14f/*1.638400e+04*/) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + mixes[0] = 0x0p+0f/*0.000000e+00*/; + for (int i_split_1 = 0; i_split_1 < 7; ++i_split_1) { + mixes[0] = (mixes[0] + gemm_out_mul[(((((int64_t)((int)blockIdx.x)) * (int64_t)24) + ((((int64_t)i_split_1) * ((int64_t)num_tokens)) * (int64_t)24)) + (((int64_t)((int)threadIdx.x)) % (int64_t)24))]); + } + mixes[0] = (mixes[0] * rms[0]); + if ((((int)threadIdx.x) / 24) == 0) { + ((float*)buf_dyn_shmem)[(((int)threadIdx.x) % 24)] = mixes[0]; + } + __syncthreads(); + if (((int)threadIdx.x) < 32) { + if (((int)threadIdx.x) < 4) { + post_mix[((((int64_t)((int)blockIdx.x)) * (int64_t)4) + ((int64_t)((int)threadIdx.x)))] = ((0x1p+0f/*1.000000e+00*/ / (0x1p+0f/*1.000000e+00*/ + expf((0x0p+0f/*0.000000e+00*/ - ((((float*)buf_dyn_shmem)[(((int)threadIdx.x) + 4)] * hc_scale[1]) + hc_base[(((int)threadIdx.x) + 4)]))))) * 0x1p+1f/*2.000000e+00*/); + } + cm[0] = ((((float*)buf_dyn_shmem)[((((int)threadIdx.x) & 15) + 8)] * hc_scale[2]) + hc_base[((((int)threadIdx.x) & 15) + 8)]); + row_max[0] = -CUDART_INF_F; + row_max[0] = max(row_max[0], cm[0]); + row_max[0] = tl::AllReduce>::run(row_max[0]); + cm[0] = expf((cm[0] - row_max[0])); + row_sum[0] = 0x0p+0f/*0.000000e+00*/; + row_sum[0] = (row_sum[0] + cm[0]); + row_sum[0] = tl::AllReduce>::run(row_sum[0]); + cm[0] = ((cm[0] / row_sum[0]) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/); + col_sum[0] = 0x0p+0f/*0.000000e+00*/; + col_sum[0] = (col_sum[0] + cm[0]); + col_sum[0] = tl::AllReduce>::run(col_sum[0]); + cm[0] = (cm[0] / (col_sum[0] + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + for (int __1 = 0; __1 < 19; ++__1) { + row_sum[0] = 0x0p+0f/*0.000000e+00*/; + row_sum[0] = (row_sum[0] + cm[0]); + row_sum[0] = tl::AllReduce>::run(row_sum[0]); + cm[0] = (cm[0] / (row_sum[0] + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + col_sum[0] = 0x0p+0f/*0.000000e+00*/; + col_sum[0] = (col_sum[0] + cm[0]); + col_sum[0] = tl::AllReduce>::run(col_sum[0]); + cm[0] = (cm[0] / (col_sum[0] + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + } + if ((((int)threadIdx.x) >> 4) == 0) { + comb_mix[((((int64_t)((int)blockIdx.x)) * (int64_t)16) + (((int64_t)((int)threadIdx.x)) & (int64_t)15))] = cm[0]; + } + } else { + if (((int)threadIdx.x) < 36) { + ((float*)buf_dyn_shmem)[(((int)threadIdx.x) + 7224)] = ((0x1p+0f/*1.000000e+00*/ / (0x1p+0f/*1.000000e+00*/ + expf((0x0p+0f/*0.000000e+00*/ - ((((float*)buf_dyn_shmem)[(((int)threadIdx.x) - 32)] * hc_scale[0]) + hc_base[(((int)threadIdx.x) - 32)]))))) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/); + } + #pragma unroll + for (int i = 0; i < 4; ++i) { + float broadcast_var = 0x0p+0f/*0.000000e+00*/; + *(float4*)(sumsq_per_pos + (i * 4)) = make_float4(broadcast_var, broadcast_var, broadcast_var, broadcast_var); + } + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_1 = 0; i_1 < 8; ++i_1) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i_1 >> 1) * 1024) + (((((i_1 * 64) + ((int)threadIdx.x)) + 96) & 127) * 8)) + 48)])), (&(residual[(((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + ((((int64_t)i_1) >> (int64_t)1) * (int64_t)4096)) + (((((((int64_t)i_1) * (int64_t)64) + ((int64_t)((int)threadIdx.x))) + (int64_t)96) & (int64_t)127) * (int64_t)8))]))); + } + tl::cp_async_commit(); + #pragma unroll + for (int i_2 = 0; i_2 < 8; ++i_2) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i_2 >> 1) * 1024) + (((((i_2 * 64) + ((int)threadIdx.x)) + 96) & 127) * 8)) + 4144)])), (&(residual[((((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + ((((int64_t)i_2) >> (int64_t)1) * (int64_t)4096)) + (((((((int64_t)i_2) * (int64_t)64) + ((int64_t)((int)threadIdx.x))) + (int64_t)96) & (int64_t)127) * (int64_t)8)) + (int64_t)1024)]))); + } + tl::cp_async_commit(); + for (int i0_h = 0; i0_h < 2; ++i0_h) { + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_3 = 0; i_3 < 8; ++i_3) { + *(uint4*)(xs_local_cast + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + ((((i0_h * 4096) + (i_3 * 512)) + (((int)threadIdx.x) * 8)) - 208)); + for (int vec = 0; vec < 2; ++vec) { + float4 __2; + uint2 v_ = *(uint2*)(xs_local_cast + (vec * 4)); + ((float2*)(&__2))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v_))[0]); + ((float2*)(&__2))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v_))[1]); + *(float4*)(xl + ((i_3 * 8) + (vec * 4))) = __2; + } + } + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_4 = 0; i_4 < 8; ++i_4) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i0_h * 4096) + ((i_4 >> 1) * 1024)) + (((((i_4 * 64) + ((int)threadIdx.x)) + 96) & 127) * 8)) + 48)])), (&(residual[(((((((int64_t)((int)blockIdx.x)) * (int64_t)16384) + ((((int64_t)i_4) >> (int64_t)1) * (int64_t)4096)) + (((int64_t)i0_h) * (int64_t)1024)) + (((((((int64_t)i_4) * (int64_t)64) + ((int64_t)((int)threadIdx.x))) + (int64_t)96) & (int64_t)127) * (int64_t)8)) + (int64_t)2048)]))); + } + tl::cp_async_commit(); + #pragma unroll + for (int i_5 = 0; i_5 < 4; ++i_5) { + float broadcast_var_1 = 0x0p+0f/*0.000000e+00*/; + *(float4*)(ol + (i_5 * 4)) = make_float4(broadcast_var_1, broadcast_var_1, broadcast_var_1, broadcast_var_1); + } + tl::__sync_thread_partial<3, 64>(); + for (int i_hc = 0; i_hc < 4; ++i_hc) { + float pre = ((float*)buf_dyn_shmem)[(i_hc + 7256)]; + #pragma unroll + for (int i_6 = 0; i_6 < 16; ++i_6) { + ol[i_6] = (ol[i_6] + (pre * xl[((i_hc * 16) + i_6)])); + } + } + #pragma unroll + for (int i_7 = 0; i_7 < 4; ++i_7) { + float4 __3; + float4 v__1 = *(float4*)(sumsq_per_pos + (i_7 * 4)); + float4 __4; + float4 v__2 = *(float4*)(ol + (i_7 * 4)); + __4.x = (v__2.x*v__2.x); + __4.y = (v__2.y*v__2.y); + __4.z = (v__2.z*v__2.z); + __4.w = (v__2.w*v__2.w); + __3.x = (v__1.x+__4.x); + __3.y = (v__1.y+__4.y); + __3.z = (v__1.z+__4.z); + __3.w = (v__1.w+__4.w); + *(float4*)(sumsq_per_pos + (i_7 * 4)) = __3; + uint2 __5; + float4 v__3 = *(float4*)(ol + (i_7 * 4)); + (reinterpret_cast<__nv_bfloat162*>(&__5))[0] = __float22bfloat162_rn(((float2*)(&v__3))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__5))[1] = __float22bfloat162_rn(((float2*)(&v__3))[1]); + *(uint2*)(((bfloat16_t*)buf_dyn_shmem) + (((((i0_h * 1024) + ((i_7 >> 1) * 512)) + (((int)threadIdx.x) * 8)) + ((i_7 & 1) * 4)) + 7984)) = __5; + } + } + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_8 = 0; i_8 < 8; ++i_8) { + *(uint4*)(xs_local_cast_1 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_8 * 512) + (((int)threadIdx.x) * 8)) - 208)); + for (int vec_1 = 0; vec_1 < 2; ++vec_1) { + float4 __6; + uint2 v__4 = *(uint2*)(xs_local_cast_1 + (vec_1 * 4)); + ((float2*)(&__6))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__4))[0]); + ((float2*)(&__6))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__4))[1]); + *(float4*)(xl + ((i_8 * 8) + (vec_1 * 4))) = __6; + } + } + #pragma unroll + for (int i_9 = 0; i_9 < 4; ++i_9) { + float broadcast_var_2 = 0x0p+0f/*0.000000e+00*/; + *(float4*)(ol + (i_9 * 4)) = make_float4(broadcast_var_2, broadcast_var_2, broadcast_var_2, broadcast_var_2); + } + for (int i_hc_1 = 0; i_hc_1 < 4; ++i_hc_1) { + float pre_1 = ((float*)buf_dyn_shmem)[(i_hc_1 + 7256)]; + #pragma unroll + for (int i_10 = 0; i_10 < 16; ++i_10) { + ol[i_10] = (ol[i_10] + (pre_1 * xl[((i_hc_1 * 16) + i_10)])); + } + } + #pragma unroll + for (int i_11 = 0; i_11 < 4; ++i_11) { + float4 __7; + float4 v__5 = *(float4*)(sumsq_per_pos + (i_11 * 4)); + float4 __8; + float4 v__6 = *(float4*)(ol + (i_11 * 4)); + __8.x = (v__6.x*v__6.x); + __8.y = (v__6.y*v__6.y); + __8.z = (v__6.z*v__6.z); + __8.w = (v__6.w*v__6.w); + __7.x = (v__5.x+__8.x); + __7.y = (v__5.y+__8.y); + __7.z = (v__5.z+__8.z); + __7.w = (v__5.w+__8.w); + *(float4*)(sumsq_per_pos + (i_11 * 4)) = __7; + uint2 __9; + float4 v__7 = *(float4*)(ol + (i_11 * 4)); + (reinterpret_cast<__nv_bfloat162*>(&__9))[0] = __float22bfloat162_rn(((float2*)(&v__7))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__9))[1] = __float22bfloat162_rn(((float2*)(&v__7))[1]); + *(uint2*)(((bfloat16_t*)buf_dyn_shmem) + (((((i_11 >> 1) * 512) + (((int)threadIdx.x) * 8)) + ((i_11 & 1) * 4)) + 10032)) = __9; + } + tl::cp_async_wait<0>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_12 = 0; i_12 < 8; ++i_12) { + *(uint4*)(xs_local_cast_2 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_12 * 512) + (((int)threadIdx.x) * 8)) + 3888)); + for (int vec_2 = 0; vec_2 < 2; ++vec_2) { + float4 __10; + uint2 v__8 = *(uint2*)(xs_local_cast_2 + (vec_2 * 4)); + ((float2*)(&__10))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__8))[0]); + ((float2*)(&__10))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__8))[1]); + *(float4*)(xl + ((i_12 * 8) + (vec_2 * 4))) = __10; + } + } + #pragma unroll + for (int i_13 = 0; i_13 < 4; ++i_13) { + float broadcast_var_3 = 0x0p+0f/*0.000000e+00*/; + *(float4*)(ol + (i_13 * 4)) = make_float4(broadcast_var_3, broadcast_var_3, broadcast_var_3, broadcast_var_3); + } + for (int i_hc_2 = 0; i_hc_2 < 4; ++i_hc_2) { + float pre_2 = ((float*)buf_dyn_shmem)[(i_hc_2 + 7256)]; + #pragma unroll + for (int i_14 = 0; i_14 < 16; ++i_14) { + ol[i_14] = (ol[i_14] + (pre_2 * xl[((i_hc_2 * 16) + i_14)])); + } + } + #pragma unroll + for (int i_15 = 0; i_15 < 4; ++i_15) { + float4 __11; + float4 v__9 = *(float4*)(sumsq_per_pos + (i_15 * 4)); + float4 __12; + float4 v__10 = *(float4*)(ol + (i_15 * 4)); + __12.x = (v__10.x*v__10.x); + __12.y = (v__10.y*v__10.y); + __12.z = (v__10.z*v__10.z); + __12.w = (v__10.w*v__10.w); + __11.x = (v__9.x+__12.x); + __11.y = (v__9.y+__12.y); + __11.z = (v__9.z+__12.z); + __11.w = (v__9.w+__12.w); + *(float4*)(sumsq_per_pos + (i_15 * 4)) = __11; + uint2 __13; + float4 v__11 = *(float4*)(ol + (i_15 * 4)); + (reinterpret_cast<__nv_bfloat162*>(&__13))[0] = __float22bfloat162_rn(((float2*)(&v__11))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__13))[1] = __float22bfloat162_rn(((float2*)(&v__11))[1]); + *(uint2*)(((bfloat16_t*)buf_dyn_shmem) + (((((i_15 >> 1) * 512) + (((int)threadIdx.x) * 8)) + ((i_15 & 1) * 4)) + 11056)) = __13; + } + sumsq[0] = 0x0p+0f/*0.000000e+00*/; + #pragma unroll + for (int rv = 0; rv < 16; ++rv) { + sumsq[0] = (sumsq[0] + sumsq_per_pos[(((rv & 1) * 8) + (rv >> 1))]); + } + tl::__sync_thread_partial<3, 64>(); + sumsq[0] = tl::AllReduce>::run(sumsq[0], (&(((float*)buf_dyn_shmem)[7192]))); + rsqrt_norm[0] = rsqrtf(((sumsq[0] / 0x1p+12f/*4.096000e+03*/) + 0x1.0c6f7a0b5ed8dp-20f/*1.000000e-06*/)); + #pragma unroll + for (int i_16 = 0; i_16 < 2; ++i_16) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[(((i_16 * 512) + (((int)threadIdx.x) * 8)) + 12080)])), (&(norm_weight[(((i_16 * 512) + (((int)threadIdx.x) * 8)) - 256)]))); + } + tl::cp_async_commit(); + #pragma unroll + for (int i_17 = 0; i_17 < 2; ++i_17) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[(((i_17 * 512) + (((int)threadIdx.x) * 8)) + 13104)])), (&(norm_weight[(((i_17 * 512) + (((int)threadIdx.x) * 8)) + 768)]))); + } + tl::cp_async_commit(); + for (int i0_h_1 = 0; i0_h_1 < 2; ++i0_h_1) { + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_18 = 0; i_18 < 2; ++i_18) { + *(uint4*)(w_shared_local_cast_3 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + ((((i0_h_1 * 1024) + (i_18 * 512)) + (((int)threadIdx.x) * 8)) + 12080)); + for (int vec_3 = 0; vec_3 < 2; ++vec_3) { + float4 __14; + uint2 v__12 = *(uint2*)(w_shared_local_cast_3 + (vec_3 * 4)); + ((float2*)(&__14))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__12))[0]); + ((float2*)(&__14))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__12))[1]); + *(float4*)(w_local + ((i_18 * 8) + (vec_3 * 4))) = __14; + } + } + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_19 = 0; i_19 < 2; ++i_19) { + tl::cp_async_gs<16>((&(((bfloat16_t*)buf_dyn_shmem)[((((i0_h_1 * 1024) + (i_19 * 512)) + (((int)threadIdx.x) * 8)) + 12080)])), (&(norm_weight[((((i0_h_1 * 1024) + (i_19 * 512)) + (((int)threadIdx.x) * 8)) + 1792)]))); + } + tl::cp_async_commit(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_20 = 0; i_20 < 2; ++i_20) { + *(uint4*)(output_shared_local_cast_4 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + ((((i0_h_1 * 1024) + (i_20 * 512)) + (((int)threadIdx.x) * 8)) + 7984)); + for (int vec_4 = 0; vec_4 < 2; ++vec_4) { + float4 __15; + float4 __16; + float4 __17; + uint2 v__13 = *(uint2*)(output_shared_local_cast_4 + (vec_4 * 4)); + ((float2*)(&__17))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__13))[0]); + ((float2*)(&__17))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__13))[1]); + float4 v__14 = make_float4(rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0]); + __16.x = (__17.x*v__14.x); + __16.y = (__17.y*v__14.y); + __16.z = (__17.z*v__14.z); + __16.w = (__17.w*v__14.w); + float4 v__15 = *(float4*)(w_local + ((i_20 * 8) + (vec_4 * 4))); + __15.x = (__16.x*v__15.x); + __15.y = (__16.y*v__15.y); + __15.z = (__16.z*v__15.z); + __15.w = (__16.w*v__15.w); + *(float4*)(ol_1 + ((i_20 * 8) + (vec_4 * 4))) = __15; + } + } + #pragma unroll + for (int i_21 = 0; i_21 < 2; ++i_21) { + for (int vec_5 = 0; vec_5 < 2; ++vec_5) { + uint2 __18; + float4 v__16 = *(float4*)(ol_1 + ((i_21 * 8) + (vec_5 * 4))); + (reinterpret_cast<__nv_bfloat162*>(&__18))[0] = __float22bfloat162_rn(((float2*)(&v__16))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__18))[1] = __float22bfloat162_rn(((float2*)(&v__16))[1]); + *(uint2*)(layer_input_local_cast_5 + (vec_5 * 4)) = __18; + } + *(uint4*)(layer_input + (((((((int64_t)((int)blockIdx.x)) * (int64_t)4096) + (((int64_t)i0_h_1) * (int64_t)1024)) + (((int64_t)i_21) * (int64_t)512)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8)) - (int64_t)256)) = *(uint4*)(layer_input_local_cast_5 + 0); + } + } + tl::cp_async_wait<1>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_22 = 0; i_22 < 2; ++i_22) { + *(uint4*)(w_shared_local_cast_6 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_22 * 512) + (((int)threadIdx.x) * 8)) + 12080)); + for (int vec_6 = 0; vec_6 < 2; ++vec_6) { + float4 __19; + uint2 v__17 = *(uint2*)(w_shared_local_cast_6 + (vec_6 * 4)); + ((float2*)(&__19))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__17))[0]); + ((float2*)(&__19))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__17))[1]); + *(float4*)(w_local + ((i_22 * 8) + (vec_6 * 4))) = __19; + } + } + #pragma unroll + for (int i_23 = 0; i_23 < 2; ++i_23) { + *(uint4*)(output_shared_local_cast_7 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_23 * 512) + (((int)threadIdx.x) * 8)) + 10032)); + for (int vec_7 = 0; vec_7 < 2; ++vec_7) { + float4 __20; + float4 __21; + float4 __22; + uint2 v__18 = *(uint2*)(output_shared_local_cast_7 + (vec_7 * 4)); + ((float2*)(&__22))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__18))[0]); + ((float2*)(&__22))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__18))[1]); + float4 v__19 = make_float4(rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0]); + __21.x = (__22.x*v__19.x); + __21.y = (__22.y*v__19.y); + __21.z = (__22.z*v__19.z); + __21.w = (__22.w*v__19.w); + float4 v__20 = *(float4*)(w_local + ((i_23 * 8) + (vec_7 * 4))); + __20.x = (__21.x*v__20.x); + __20.y = (__21.y*v__20.y); + __20.z = (__21.z*v__20.z); + __20.w = (__21.w*v__20.w); + *(float4*)(ol_1 + ((i_23 * 8) + (vec_7 * 4))) = __20; + } + } + #pragma unroll + for (int i_24 = 0; i_24 < 2; ++i_24) { + for (int vec_8 = 0; vec_8 < 2; ++vec_8) { + uint2 __23; + float4 v__21 = *(float4*)(ol_1 + ((i_24 * 8) + (vec_8 * 4))); + (reinterpret_cast<__nv_bfloat162*>(&__23))[0] = __float22bfloat162_rn(((float2*)(&v__21))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__23))[1] = __float22bfloat162_rn(((float2*)(&v__21))[1]); + *(uint2*)(layer_input_local_cast_8 + (vec_8 * 4)) = __23; + } + *(uint4*)(layer_input + ((((((int64_t)((int)blockIdx.x)) * (int64_t)4096) + (((int64_t)i_24) * (int64_t)512)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8)) + (int64_t)1792)) = *(uint4*)(layer_input_local_cast_8 + 0); + } + tl::cp_async_wait<0>(); + tl::__sync_thread_partial<3, 64>(); + #pragma unroll + for (int i_25 = 0; i_25 < 2; ++i_25) { + *(uint4*)(w_shared_local_cast_9 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_25 * 512) + (((int)threadIdx.x) * 8)) + 13104)); + for (int vec_9 = 0; vec_9 < 2; ++vec_9) { + float4 __24; + uint2 v__22 = *(uint2*)(w_shared_local_cast_9 + (vec_9 * 4)); + ((float2*)(&__24))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__22))[0]); + ((float2*)(&__24))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__22))[1]); + *(float4*)(w_local + ((i_25 * 8) + (vec_9 * 4))) = __24; + } + } + #pragma unroll + for (int i_26 = 0; i_26 < 2; ++i_26) { + *(uint4*)(output_shared_local_cast_10 + 0) = *(uint4*)(((bfloat16_t*)buf_dyn_shmem) + (((i_26 * 512) + (((int)threadIdx.x) * 8)) + 11056)); + for (int vec_10 = 0; vec_10 < 2; ++vec_10) { + float4 __25; + float4 __26; + float4 __27; + uint2 v__23 = *(uint2*)(output_shared_local_cast_10 + (vec_10 * 4)); + ((float2*)(&__27))[0] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__23))[0]); + ((float2*)(&__27))[1] = __bfloat1622float2((reinterpret_cast<__nv_bfloat162*>(&v__23))[1]); + float4 v__24 = make_float4(rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0], rsqrt_norm[0]); + __26.x = (__27.x*v__24.x); + __26.y = (__27.y*v__24.y); + __26.z = (__27.z*v__24.z); + __26.w = (__27.w*v__24.w); + float4 v__25 = *(float4*)(w_local + ((i_26 * 8) + (vec_10 * 4))); + __25.x = (__26.x*v__25.x); + __25.y = (__26.y*v__25.y); + __25.z = (__26.z*v__25.z); + __25.w = (__26.w*v__25.w); + *(float4*)(ol_1 + ((i_26 * 8) + (vec_10 * 4))) = __25; + } + } + #pragma unroll + for (int i_27 = 0; i_27 < 2; ++i_27) { + for (int vec_11 = 0; vec_11 < 2; ++vec_11) { + uint2 __28; + float4 v__26 = *(float4*)(ol_1 + ((i_27 * 8) + (vec_11 * 4))); + (reinterpret_cast<__nv_bfloat162*>(&__28))[0] = __float22bfloat162_rn(((float2*)(&v__26))[0]); + (reinterpret_cast<__nv_bfloat162*>(&__28))[1] = __float22bfloat162_rn(((float2*)(&v__26))[1]); + *(uint2*)(layer_input_local_cast_11 + (vec_11 * 4)) = __28; + } + *(uint4*)(layer_input + ((((((int64_t)((int)blockIdx.x)) * (int64_t)4096) + (((int64_t)i_27) * (int64_t)512)) + (((int64_t)((int)threadIdx.x)) * (int64_t)8)) + (int64_t)2816)) = *(uint4*)(layer_input_local_cast_11 + 0); + } + } + cudaTriggerProgrammaticLaunchCompletion(); +} + diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/ee551f0fd55a5f344ee5ec2ee5aa79c7656eb4c9efbd0c4a7c2d3107c1e82478/host_kernel.cu b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/ee551f0fd55a5f344ee5ec2ee5aa79c7656eb4c9efbd0c4a7c2d3107c1e82478/host_kernel.cu new file mode 100644 index 0000000..7a8af95 --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/ee551f0fd55a5f344ee5ec2ee5aa79c7656eb4c9efbd0c4a7c2d3107c1e82478/host_kernel.cu @@ -0,0 +1,3359 @@ +// tilelang target: c -keys=cpu +#define TVM_EXPORTS +#include "tvm/runtime/base.h" +#include "tvm/runtime/c_backend_api.h" +#include "tvm/ffi/c_api.h" +#include +#include +#include +#ifdef __OBJC__ +#include "tvm/runtime/device_api.h" +#include "tvm/ffi/function.h" +#include +#include +#include +#endif +void* __tvm_ffi__library_ctx = NULL; +static void* __tvm_error_ndim_mismatch_packed = NULL; +static void* __tvm_error_dtype_mismatch_packed = NULL; +static void* __tvm_error_expect_eq_packed = NULL; +static void* __tvm_error_constraint_violation_packed = NULL; +static void* __tvm_error_byte_offset_mismatch_packed = NULL; +static void* __tvm_error_device_type_mismatch_packed = NULL; +static void* __tvm_error_null_ptr_packed = NULL; +static void* __tvm_set_device_packed = NULL; +static void* mhc_pre_big_fuse_with_norm_tilelang_kernel_packed = NULL; +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_mhc_pre_big_fuse_with_norm_tilelang(void* self_handle, void* args, int32_t num_args, void* result); +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_mhc_pre_big_fuse_with_norm_tilelang(void* self_handle, void* args, int32_t num_args, void* result) { + __attribute__((aligned(64))) TVMFFIAny stack[16]; + void* stack_ffi_any = stack; + if (!((num_args == 9))) { + char __tvm_assert_msg_buf[512]; + snprintf(__tvm_assert_msg_buf, 512, "%s; expected: %lld, got: %lld", "mhc_pre_big_fuse_with_norm_tilelang: num_args should be 9", (long long)(num_args), (long long)(9)); + TVMFFIErrorSetRaisedFromCStr("RuntimeError", __tvm_assert_msg_buf); + return -1; + } + if (!(!(args == NULL))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang: args pointer is NULL"); + return -1; + } + int32_t gemm_out_mul_type_index = (((TVMFFIAny*)args)[0].type_index); + if (!(((((gemm_out_mul_type_index == 0) || (gemm_out_mul_type_index == 4)) || (gemm_out_mul_type_index == 7)) || (64 <= gemm_out_mul_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input gemm_out_mul expected pointer or tensor handle"); + return -1; + } + int32_t gemm_out_sqrsum_type_index = (((TVMFFIAny*)args)[1].type_index); + if (!(((((gemm_out_sqrsum_type_index == 0) || (gemm_out_sqrsum_type_index == 4)) || (gemm_out_sqrsum_type_index == 7)) || (64 <= gemm_out_sqrsum_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input gemm_out_sqrsum expected pointer or tensor handle"); + return -1; + } + int32_t hc_scale_type_index = (((TVMFFIAny*)args)[2].type_index); + if (!(((((hc_scale_type_index == 0) || (hc_scale_type_index == 4)) || (hc_scale_type_index == 7)) || (64 <= hc_scale_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input hc_scale expected pointer or tensor handle"); + return -1; + } + int32_t hc_base_type_index = (((TVMFFIAny*)args)[3].type_index); + if (!(((((hc_base_type_index == 0) || (hc_base_type_index == 4)) || (hc_base_type_index == 7)) || (64 <= hc_base_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input hc_base expected pointer or tensor handle"); + return -1; + } + int32_t residual_type_index = (((TVMFFIAny*)args)[4].type_index); + if (!(((((residual_type_index == 0) || (residual_type_index == 4)) || (residual_type_index == 7)) || (64 <= residual_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input residual expected pointer or tensor handle"); + return -1; + } + int32_t post_mix_type_index = (((TVMFFIAny*)args)[5].type_index); + if (!(((((post_mix_type_index == 0) || (post_mix_type_index == 4)) || (post_mix_type_index == 7)) || (64 <= post_mix_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input post_mix expected pointer or tensor handle"); + return -1; + } + int32_t comb_mix_type_index = (((TVMFFIAny*)args)[6].type_index); + if (!(((((comb_mix_type_index == 0) || (comb_mix_type_index == 4)) || (comb_mix_type_index == 7)) || (64 <= comb_mix_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input comb_mix expected pointer or tensor handle"); + return -1; + } + int32_t layer_input_type_index = (((TVMFFIAny*)args)[7].type_index); + if (!(((((layer_input_type_index == 0) || (layer_input_type_index == 4)) || (layer_input_type_index == 7)) || (64 <= layer_input_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input layer_input expected pointer or tensor handle"); + return -1; + } + int32_t norm_weight_type_index = (((TVMFFIAny*)args)[8].type_index); + if (!(((((norm_weight_type_index == 0) || (norm_weight_type_index == 4)) || (norm_weight_type_index == 7)) || (64 <= norm_weight_type_index)))) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "kernel mhc_pre_big_fuse_with_norm_tilelang input norm_weight expected pointer or tensor handle"); + return -1; + } + void* gemm_out_mul = ((gemm_out_mul_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[0].v_ptr) + 24)) : (((TVMFFIAny*)args)[0].v_ptr)); + void* gemm_out_sqrsum = ((gemm_out_sqrsum_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[1].v_ptr) + 24)) : (((TVMFFIAny*)args)[1].v_ptr)); + void* hc_scale = ((hc_scale_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[2].v_ptr) + 24)) : (((TVMFFIAny*)args)[2].v_ptr)); + void* hc_base = ((hc_base_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[3].v_ptr) + 24)) : (((TVMFFIAny*)args)[3].v_ptr)); + void* residual = ((residual_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[4].v_ptr) + 24)) : (((TVMFFIAny*)args)[4].v_ptr)); + void* post_mix = ((post_mix_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[5].v_ptr) + 24)) : (((TVMFFIAny*)args)[5].v_ptr)); + void* comb_mix = ((comb_mix_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[6].v_ptr) + 24)) : (((TVMFFIAny*)args)[6].v_ptr)); + void* layer_input = ((layer_input_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[7].v_ptr) + 24)) : (((TVMFFIAny*)args)[7].v_ptr)); + void* norm_weight = ((norm_weight_type_index == 70) ? ((void*)((char*)(((TVMFFIAny*)args)[8].v_ptr) + 24)) : (((TVMFFIAny*)args)[8].v_ptr)); + bool mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_is_null = (gemm_out_mul == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.gemm_out_mul is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_is_null = (gemm_out_sqrsum == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.gemm_out_sqrsum is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_hc_scale_is_null = (hc_scale == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_hc_scale_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.hc_scale is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_hc_base_is_null = (hc_base == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_hc_base_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.hc_base is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_residual_is_null = (residual == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_residual_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.residual is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_post_mix_is_null = (post_mix == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_post_mix_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.post_mix is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_comb_mix_is_null = (comb_mix == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_comb_mix_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.comb_mix is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_layer_input_is_null = (layer_input == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_layer_input_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.layer_input is expected to have non-NULL pointer"); + return -1; + } + bool mhc_pre_big_fuse_with_norm_tilelang_norm_weight_is_null = (norm_weight == NULL); + if (!(!mhc_pre_big_fuse_with_norm_tilelang_norm_weight_is_null)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "mhc_pre_big_fuse_with_norm_tilelang.norm_weight is expected to have non-NULL pointer"); + return -1; + } + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape = (((DLTensor*)gemm_out_mul)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape = (((DLTensor*)gemm_out_sqrsum)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_hc_scale_shape = (((DLTensor*)hc_scale)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_hc_base_shape = (((DLTensor*)hc_base)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_residual_shape = (((DLTensor*)residual)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape = (((DLTensor*)post_mix)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape = (((DLTensor*)comb_mix)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape = (((DLTensor*)layer_input)[0].shape); + void* mhc_pre_big_fuse_with_norm_tilelang_norm_weight_shape = (((DLTensor*)norm_weight)[0].shape); + if ((((DLTensor*)gemm_out_mul)[0].ndim) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_1; + result_1.type_index = kTVMFFINone; + result_1.zero_padding = 0; + result_1.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_1) != 0) { + return -1; + } + } + if (!((bool)1)) { + TVMFFIErrorSetRaisedFromCStr("RuntimeError", "Symbolic shape variable num_tokens requires at least one non-null buffer among: mhc_pre_big_fuse_with_norm_tilelang.gemm_out_mul, mhc_pre_big_fuse_with_norm_tilelang.gemm_out_sqrsum, mhc_pre_big_fuse_with_norm_tilelang.residual, mhc_pre_big_fuse_with_norm_tilelang.post_mix, mhc_pre_big_fuse_with_norm_tilelang.comb_mix, mhc_pre_big_fuse_with_norm_tilelang.layer_input"); + return -1; + } + int32_t num_tokens = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]); + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides = (((DLTensor*)gemm_out_mul)[0].strides); + int32_t dev_id = (((DLTensor*)gemm_out_mul)[0].device.device_id); + void* gemm_out_mul_1 = (((DLTensor*)gemm_out_mul)[0].data); + if ((((DLTensor*)gemm_out_sqrsum)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_2; + result_2.type_index = kTVMFFINone; + result_2.zero_padding = 0; + result_2.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_2) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides = (((DLTensor*)gemm_out_sqrsum)[0].strides); + void* gemm_out_sqrsum_1 = (((DLTensor*)gemm_out_sqrsum)[0].data); + if ((((DLTensor*)hc_scale)[0].ndim) != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_3; + result_3.type_index = kTVMFFINone; + result_3.zero_padding = 0; + result_3.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_3) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides = (((DLTensor*)hc_scale)[0].strides); + void* hc_scale_1 = (((DLTensor*)hc_scale)[0].data); + if ((((DLTensor*)hc_base)[0].ndim) != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_4; + result_4.type_index = kTVMFFINone; + result_4.zero_padding = 0; + result_4.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_4) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides = (((DLTensor*)hc_base)[0].strides); + void* hc_base_1 = (((DLTensor*)hc_base)[0].data); + if ((((DLTensor*)residual)[0].ndim) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_5; + result_5.type_index = kTVMFFINone; + result_5.zero_padding = 0; + result_5.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_5) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_residual_strides = (((DLTensor*)residual)[0].strides); + void* residual_1 = (((DLTensor*)residual)[0].data); + if ((((DLTensor*)post_mix)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_6; + result_6.type_index = kTVMFFINone; + result_6.zero_padding = 0; + result_6.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_6) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides = (((DLTensor*)post_mix)[0].strides); + void* post_mix_1 = (((DLTensor*)post_mix)[0].data); + if ((((DLTensor*)comb_mix)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_7; + result_7.type_index = kTVMFFINone; + result_7.zero_padding = 0; + result_7.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_7) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides = (((DLTensor*)comb_mix)[0].strides); + void* comb_mix_1 = (((DLTensor*)comb_mix)[0].data); + if ((((DLTensor*)layer_input)[0].ndim) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_8; + result_8.type_index = kTVMFFINone; + result_8.zero_padding = 0; + result_8.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_8) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides = (((DLTensor*)layer_input)[0].strides); + void* layer_input_1 = (((DLTensor*)layer_input)[0].data); + if ((((DLTensor*)norm_weight)[0].ndim) != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].ndim)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_ndim_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_ndim_mismatch", &__tvm_error_ndim_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_9; + result_9.type_index = kTVMFFINone; + result_9.zero_padding = 0; + result_9.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_ndim_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_9) != 0) { + return -1; + } + } + void* mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides = (((DLTensor*)norm_weight)[0].strides); + void* norm_weight_1 = (((DLTensor*)norm_weight)[0].data); + if ((((((DLTensor*)gemm_out_mul)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)gemm_out_mul)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)gemm_out_mul)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_10; + result_10.type_index = kTVMFFINone; + result_10.zero_padding = 0; + result_10.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_10) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[0]) != 7) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)7; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_11; + result_11.type_index = kTVMFFINone; + result_11.zero_padding = 0; + result_11.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_11) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[2]) != 24) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)24; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[2])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_12; + result_12.type_index = kTVMFFINone; + result_12.zero_padding = 0; + result_12.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_12) != 0) { + return -1; + } + } + int32_t condval; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval = 1; + } else { + condval = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[2]); + } + if (condval != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_1; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval_1 = 1; + } else { + condval_1 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[2]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_1); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_13; + result_13.type_index = kTVMFFINone; + result_13.zero_padding = 0; + result_13.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_13) != 0) { + return -1; + } + } + int32_t condval_2; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval_2 = 1; + } else { + condval_2 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[1]); + } + if ((condval_2 != 24) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_14; + result_14.type_index = kTVMFFINone; + result_14.zero_padding = 0; + result_14.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_14) != 0) { + return -1; + } + } + int32_t condval_3; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides == NULL)) { + condval_3 = 1; + } else { + condval_3 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_strides)[0]); + } + if (((num_tokens * 24) != condval_3) && (num_tokens != 0)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_15; + result_15.type_index = kTVMFFINone; + result_15.zero_padding = 0; + result_15.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_15) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)gemm_out_mul)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_16; + result_16.type_index = kTVMFFINone; + result_16.zero_padding = 0; + result_16.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_16) != 0) { + return -1; + } + } + if ((((DLTensor*)gemm_out_mul)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_17; + result_17.type_index = kTVMFFINone; + result_17.zero_padding = 0; + result_17.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_17) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (gemm_out_mul_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_mul"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_18; + result_18.type_index = kTVMFFINone; + result_18.zero_padding = 0; + result_18.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_18) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)gemm_out_sqrsum)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)gemm_out_sqrsum)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)gemm_out_sqrsum)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_19; + result_19.type_index = kTVMFFINone; + result_19.zero_padding = 0; + result_19.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_19) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[0]) != 7) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)7; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_20; + result_20.type_index = kTVMFFINone; + result_20.zero_padding = 0; + result_20.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_20) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[1])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_21; + result_21.type_index = kTVMFFINone; + result_21.zero_padding = 0; + result_21.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_21) != 0) { + return -1; + } + } + int32_t condval_4; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides == NULL)) { + condval_4 = 1; + } else { + condval_4 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides)[1]); + } + if ((condval_4 != 1) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_22; + result_22.type_index = kTVMFFINone; + result_22.zero_padding = 0; + result_22.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_22) != 0) { + return -1; + } + } + int32_t condval_5; + if ((mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides == NULL)) { + condval_5 = 1; + } else { + condval_5 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_sqrsum_strides)[0]); + } + if ((((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != condval_5) && (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != 0)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_23; + result_23.type_index = kTVMFFINone; + result_23.zero_padding = 0; + result_23.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_23) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)gemm_out_sqrsum)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_24; + result_24.type_index = kTVMFFINone; + result_24.zero_padding = 0; + result_24.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_24) != 0) { + return -1; + } + } + if ((((DLTensor*)gemm_out_sqrsum)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_25; + result_25.type_index = kTVMFFINone; + result_25.zero_padding = 0; + result_25.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_25) != 0) { + return -1; + } + } + if ((((DLTensor*)gemm_out_sqrsum)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_sqrsum)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_26; + result_26.type_index = kTVMFFINone; + result_26.zero_padding = 0; + result_26.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_26) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (gemm_out_sqrsum_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"gemm_out_sqrsum"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_27; + result_27.type_index = kTVMFFINone; + result_27.zero_padding = 0; + result_27.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_27) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)hc_scale)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)hc_scale)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)hc_scale)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_28; + result_28.type_index = kTVMFFINone; + result_28.zero_padding = 0; + result_28.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_28) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_shape)[0]) != 3) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)3; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_29; + result_29.type_index = kTVMFFINone; + result_29.zero_padding = 0; + result_29.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_29) != 0) { + return -1; + } + } + int32_t condval_6; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides == NULL)) { + condval_6 = 1; + } else { + condval_6 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides)[0]); + } + if (condval_6 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_7; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides == NULL)) { + condval_7 = 1; + } else { + condval_7 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_scale_strides)[0]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_7); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_30; + result_30.type_index = kTVMFFINone; + result_30.zero_padding = 0; + result_30.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_30) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)hc_scale)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_31; + result_31.type_index = kTVMFFINone; + result_31.zero_padding = 0; + result_31.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_31) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_scale)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_32; + result_32.type_index = kTVMFFINone; + result_32.zero_padding = 0; + result_32.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_32) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_scale)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_scale)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_33; + result_33.type_index = kTVMFFINone; + result_33.zero_padding = 0; + result_33.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_33) != 0) { + return -1; + } + } + if (hc_scale_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_scale"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_34; + result_34.type_index = kTVMFFINone; + result_34.zero_padding = 0; + result_34.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_34) != 0) { + return -1; + } + } + if ((((((DLTensor*)hc_base)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)hc_base)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)hc_base)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_35; + result_35.type_index = kTVMFFINone; + result_35.zero_padding = 0; + result_35.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_35) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_shape)[0]) != 24) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)24; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_36; + result_36.type_index = kTVMFFINone; + result_36.zero_padding = 0; + result_36.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_36) != 0) { + return -1; + } + } + int32_t condval_8; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides == NULL)) { + condval_8 = 1; + } else { + condval_8 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides)[0]); + } + if (condval_8 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_9; + if ((mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides == NULL)) { + condval_9 = 1; + } else { + condval_9 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_hc_base_strides)[0]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_9); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_37; + result_37.type_index = kTVMFFINone; + result_37.zero_padding = 0; + result_37.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_37) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)hc_base)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_38; + result_38.type_index = kTVMFFINone; + result_38.zero_padding = 0; + result_38.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_38) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_base)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_39; + result_39.type_index = kTVMFFINone; + result_39.zero_padding = 0; + result_39.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_39) != 0) { + return -1; + } + } + if ((((DLTensor*)hc_base)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)hc_base)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_40; + result_40.type_index = kTVMFFINone; + result_40.zero_padding = 0; + result_40.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_40) != 0) { + return -1; + } + } + if (hc_base_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"hc_base"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_41; + result_41.type_index = kTVMFFINone; + result_41.zero_padding = 0; + result_41.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_41) != 0) { + return -1; + } + } + if ((((((DLTensor*)residual)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)residual)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)residual)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)residual)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)residual)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_42; + result_42.type_index = kTVMFFINone; + result_42.zero_padding = 0; + result_42.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_42) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_43; + result_43.type_index = kTVMFFINone; + result_43.zero_padding = 0; + result_43.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_43) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[1]) != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_44; + result_44.type_index = kTVMFFINone; + result_44.zero_padding = 0; + result_44.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_44) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[2]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_shape)[2])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_45; + result_45.type_index = kTVMFFINone; + result_45.zero_padding = 0; + result_45.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_45) != 0) { + return -1; + } + } + int32_t condval_10; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_10 = 1; + } else { + condval_10 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[2]); + } + if (condval_10 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[2]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_11; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_11 = 1; + } else { + condval_11 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[2]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_11); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_46; + result_46.type_index = kTVMFFINone; + result_46.zero_padding = 0; + result_46.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_46) != 0) { + return -1; + } + } + int32_t condval_12; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_12 = 1; + } else { + condval_12 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[1]); + } + if (condval_12 != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_13; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_13 = 1; + } else { + condval_13 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_13); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_47; + result_47.type_index = kTVMFFINone; + result_47.zero_padding = 0; + result_47.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_47) != 0) { + return -1; + } + } + int32_t condval_14; + if ((mhc_pre_big_fuse_with_norm_tilelang_residual_strides == NULL)) { + condval_14 = 1; + } else { + condval_14 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_residual_strides)[0]); + } + if ((condval_14 != 16384) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_48; + result_48.type_index = kTVMFFINone; + result_48.zero_padding = 0; + result_48.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_48) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)residual)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_49; + result_49.type_index = kTVMFFINone; + result_49.zero_padding = 0; + result_49.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_49) != 0) { + return -1; + } + } + if ((((DLTensor*)residual)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)residual)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_50; + result_50.type_index = kTVMFFINone; + result_50.zero_padding = 0; + result_50.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_50) != 0) { + return -1; + } + } + if ((((DLTensor*)residual)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)residual)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_51; + result_51.type_index = kTVMFFINone; + result_51.zero_padding = 0; + result_51.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_51) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (residual_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"residual"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_52; + result_52.type_index = kTVMFFINone; + result_52.zero_padding = 0; + result_52.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_52) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)post_mix)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)post_mix)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)post_mix)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_53; + result_53.type_index = kTVMFFINone; + result_53.zero_padding = 0; + result_53.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_53) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_54; + result_54.type_index = kTVMFFINone; + result_54.zero_padding = 0; + result_54.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_54) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[1]) != 4) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_55; + result_55.type_index = kTVMFFINone; + result_55.zero_padding = 0; + result_55.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_55) != 0) { + return -1; + } + } + int32_t condval_15; + if ((mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides == NULL)) { + condval_15 = 1; + } else { + condval_15 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides)[1]); + } + if (condval_15 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_16; + if ((mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides == NULL)) { + condval_16 = 1; + } else { + condval_16 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_16); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_56; + result_56.type_index = kTVMFFINone; + result_56.zero_padding = 0; + result_56.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_56) != 0) { + return -1; + } + } + int32_t condval_17; + if ((mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides == NULL)) { + condval_17 = 1; + } else { + condval_17 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_post_mix_strides)[0]); + } + if ((condval_17 != 4) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_57; + result_57.type_index = kTVMFFINone; + result_57.zero_padding = 0; + result_57.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_57) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)post_mix)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_58; + result_58.type_index = kTVMFFINone; + result_58.zero_padding = 0; + result_58.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_58) != 0) { + return -1; + } + } + if ((((DLTensor*)post_mix)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_59; + result_59.type_index = kTVMFFINone; + result_59.zero_padding = 0; + result_59.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_59) != 0) { + return -1; + } + } + if ((((DLTensor*)post_mix)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)post_mix)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_60; + result_60.type_index = kTVMFFINone; + result_60.zero_padding = 0; + result_60.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_60) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (post_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"post_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_61; + result_61.type_index = kTVMFFINone; + result_61.zero_padding = 0; + result_61.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_61) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)comb_mix)[0].dtype.code) != (uint8_t)2) || ((((DLTensor*)comb_mix)[0].dtype.bits) != (uint8_t)32)) || ((((DLTensor*)comb_mix)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)32; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_62; + result_62.type_index = kTVMFFINone; + result_62.zero_padding = 0; + result_62.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_62) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_63; + result_63.type_index = kTVMFFINone; + result_63.zero_padding = 0; + result_63.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_63) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[1]) != 16) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_64; + result_64.type_index = kTVMFFINone; + result_64.zero_padding = 0; + result_64.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_64) != 0) { + return -1; + } + } + int32_t condval_18; + if ((mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides == NULL)) { + condval_18 = 1; + } else { + condval_18 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides)[1]); + } + if (condval_18 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_19; + if ((mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides == NULL)) { + condval_19 = 1; + } else { + condval_19 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_19); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_65; + result_65.type_index = kTVMFFINone; + result_65.zero_padding = 0; + result_65.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_65) != 0) { + return -1; + } + } + int32_t condval_20; + if ((mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides == NULL)) { + condval_20 = 1; + } else { + condval_20 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_comb_mix_strides)[0]); + } + if ((condval_20 != 16) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_66; + result_66.type_index = kTVMFFINone; + result_66.zero_padding = 0; + result_66.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_66) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)comb_mix)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_67; + result_67.type_index = kTVMFFINone; + result_67.zero_padding = 0; + result_67.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_67) != 0) { + return -1; + } + } + if ((((DLTensor*)comb_mix)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_68; + result_68.type_index = kTVMFFINone; + result_68.zero_padding = 0; + result_68.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_68) != 0) { + return -1; + } + } + if ((((DLTensor*)comb_mix)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)comb_mix)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_69; + result_69.type_index = kTVMFFINone; + result_69.zero_padding = 0; + result_69.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_69) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (comb_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"comb_mix"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_70; + result_70.type_index = kTVMFFINone; + result_70.zero_padding = 0; + result_70.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_70) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)layer_input)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)layer_input)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)layer_input)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_71; + result_71.type_index = kTVMFFINone; + result_71.zero_padding = 0; + result_71.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_71) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1]) != ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[0])) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_gemm_out_mul_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_72; + result_72.type_index = kTVMFFINone; + result_72.zero_padding = 0; + result_72.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_72) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[1]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_shape)[1])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_73; + result_73.type_index = kTVMFFINone; + result_73.zero_padding = 0; + result_73.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_73) != 0) { + return -1; + } + } + int32_t condval_21; + if ((mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides == NULL)) { + condval_21 = 1; + } else { + condval_21 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides)[1]); + } + if (condval_21 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[1]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_22; + if ((mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides == NULL)) { + condval_22 = 1; + } else { + condval_22 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides)[1]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_22); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_74; + result_74.type_index = kTVMFFINone; + result_74.zero_padding = 0; + result_74.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_74) != 0) { + return -1; + } + } + int32_t condval_23; + if ((mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides == NULL)) { + condval_23 = 1; + } else { + condval_23 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_layer_input_strides)[0]); + } + if ((condval_23 != 4096) && (num_tokens != 1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_constraint_violation_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_constraint_violation", &__tvm_error_constraint_violation_packed) != 0) { + return -1; + } + } + TVMFFIAny result_75; + result_75.type_index = kTVMFFINone; + result_75.zero_padding = 0; + result_75.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_constraint_violation_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_75) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)layer_input)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_76; + result_76.type_index = kTVMFFINone; + result_76.zero_padding = 0; + result_76.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_76) != 0) { + return -1; + } + } + if ((((DLTensor*)layer_input)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_77; + result_77.type_index = kTVMFFINone; + result_77.zero_padding = 0; + result_77.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_77) != 0) { + return -1; + } + } + if ((((DLTensor*)layer_input)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)layer_input)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_78; + result_78.type_index = kTVMFFINone; + result_78.zero_padding = 0; + result_78.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_78) != 0) { + return -1; + } + } + if (num_tokens != 0) { + if (layer_input_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"layer_input"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_79; + result_79.type_index = kTVMFFINone; + result_79.zero_padding = 0; + result_79.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_79) != 0) { + return -1; + } + } + } else { + } + if ((((((DLTensor*)norm_weight)[0].dtype.code) != (uint8_t)4) || ((((DLTensor*)norm_weight)[0].dtype.bits) != (uint8_t)16)) || ((((DLTensor*)norm_weight)[0].dtype.lanes) != (uint16_t)1)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].dtype.code)); + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].dtype.bits)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].dtype.lanes)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)4; + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = (int64_t)16; + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = (int64_t)0; + if (__tvm_error_dtype_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_dtype_mismatch", &__tvm_error_dtype_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_80; + result_80.type_index = kTVMFFINone; + result_80.zero_padding = 0; + result_80.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_dtype_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 8, &result_80) != 0) { + return -1; + } + } + if (((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_shape)[0]) != 4096) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"shape[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)4096; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_shape)[0])); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_81; + result_81.type_index = kTVMFFINone; + result_81.zero_padding = 0; + result_81.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_81) != 0) { + return -1; + } + } + int32_t condval_24; + if ((mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides == NULL)) { + condval_24 = 1; + } else { + condval_24 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides)[0]); + } + if (condval_24 != 1) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"strides[0]"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)1; + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + int32_t condval_25; + if ((mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides == NULL)) { + condval_25 = 1; + } else { + condval_25 = ((int32_t)((int64_t*)mhc_pre_big_fuse_with_norm_tilelang_norm_weight_strides)[0]); + } + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)condval_25); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_82; + result_82.type_index = kTVMFFINone; + result_82.zero_padding = 0; + result_82.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_82) != 0) { + return -1; + } + } + if ((uint64_t)0 != (((DLTensor*)norm_weight)[0].byte_offset)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].byte_offset)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_byte_offset_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_byte_offset_mismatch", &__tvm_error_byte_offset_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_83; + result_83.type_index = kTVMFFINone; + result_83.zero_padding = 0; + result_83.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_byte_offset_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_83) != 0) { + return -1; + } + } + if ((((DLTensor*)norm_weight)[0].device.device_id) != (((DLTensor*)gemm_out_mul)[0].device.device_id)) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"device_id"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)gemm_out_mul)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].device.device_id)); + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = (int64_t)0; + if (__tvm_error_expect_eq_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_expect_eq", &__tvm_error_expect_eq_packed) != 0) { + return -1; + } + } + TVMFFIAny result_84; + result_84.type_index = kTVMFFINone; + result_84.zero_padding = 0; + result_84.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_expect_eq_packed, (TVMFFIAny*) stack_ffi_any, 5, &result_84) != 0) { + return -1; + } + } + if ((((DLTensor*)norm_weight)[0].device.device_type) != 2) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)2; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = ((int64_t)(((DLTensor*)norm_weight)[0].device.device_type)); + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = (int64_t)0; + if (__tvm_error_device_type_mismatch_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_device_type_mismatch", &__tvm_error_device_type_mismatch_packed) != 0) { + return -1; + } + } + TVMFFIAny result_85; + result_85.type_index = kTVMFFINone; + result_85.zero_padding = 0; + result_85.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_device_type_mismatch_packed, (TVMFFIAny*) stack_ffi_any, 4, &result_85) != 0) { + return -1; + } + } + if (norm_weight_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = (void*)"mhc_pre_big_fuse_with_norm_tilelang"; + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = (void*)"norm_weight"; + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 8; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = (void*)"data pointer"; + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = (int64_t)0; + if (__tvm_error_null_ptr_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_error_null_ptr", &__tvm_error_null_ptr_packed) != 0) { + return -1; + } + } + TVMFFIAny result_86; + result_86.type_index = kTVMFFINone; + result_86.zero_padding = 0; + result_86.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_error_null_ptr_packed, (TVMFFIAny*) stack_ffi_any, 3, &result_86) != 0) { + return -1; + } + } + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = ((int64_t)2); + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = ((int64_t)dev_id); + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = (int64_t)0; + if (__tvm_set_device_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "__tvm_set_device", &__tvm_set_device_packed) != 0) { + return -1; + } + } + TVMFFIAny result_87; + result_87.type_index = kTVMFFINone; + result_87.zero_padding = 0; + result_87.v_int64 = 0; + if (TVMFFIFunctionCall(__tvm_set_device_packed, (TVMFFIAny*) stack_ffi_any, 2, &result_87) != 0) { + return -1; + } + if (comb_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[0].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[0].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[0].v_ptr) = comb_mix_1; + if (gemm_out_mul_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[1].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[1].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[1].v_ptr) = gemm_out_mul_1; + if (gemm_out_sqrsum_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[2].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[2].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[2].v_ptr) = gemm_out_sqrsum_1; + if (hc_base_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[3].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[3].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[3].v_ptr) = hc_base_1; + if (hc_scale_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[4].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[4].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[4].v_ptr) = hc_scale_1; + if (layer_input_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[5].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[5].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[5].v_ptr) = layer_input_1; + if (norm_weight_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[6].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[6].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[6].v_ptr) = norm_weight_1; + if (post_mix_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[7].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[7].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[7].v_ptr) = post_mix_1; + if (residual_1 == NULL) { + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 0; + } else { + (((TVMFFIAny*)stack_ffi_any)[8].type_index) = 4; + } + (((TVMFFIAny*)stack_ffi_any)[8].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_int64) = 0; + (((TVMFFIAny*)stack_ffi_any)[8].v_ptr) = residual_1; + (((TVMFFIAny*)stack_ffi_any)[9].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[9].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[9].v_int64) = ((int64_t)num_tokens); + (((TVMFFIAny*)stack_ffi_any)[10].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[10].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[10].v_int64) = ((int64_t)num_tokens); + (((TVMFFIAny*)stack_ffi_any)[11].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[11].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[11].v_int64) = ((int64_t)96); + (((TVMFFIAny*)stack_ffi_any)[12].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[12].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[12].v_int64) = ((int64_t)1); + (((TVMFFIAny*)stack_ffi_any)[13].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[13].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[13].v_int64) = ((int64_t)1); + (((TVMFFIAny*)stack_ffi_any)[14].type_index) = 1; + (((TVMFFIAny*)stack_ffi_any)[14].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[14].v_int64) = ((int64_t)29040); + (((TVMFFIAny*)stack_ffi_any)[15].type_index) = 0; + (((TVMFFIAny*)stack_ffi_any)[15].zero_padding) = 0; + (((TVMFFIAny*)stack_ffi_any)[15].v_int64) = (int64_t)0; + if (mhc_pre_big_fuse_with_norm_tilelang_kernel_packed == NULL) { + if (TVMBackendGetFuncFromEnv(__tvm_ffi__library_ctx, "mhc_pre_big_fuse_with_norm_tilelang_kernel", &mhc_pre_big_fuse_with_norm_tilelang_kernel_packed) != 0) { + return -1; + } + } + TVMFFIAny result_88; + result_88.type_index = kTVMFFINone; + result_88.zero_padding = 0; + result_88.v_int64 = 0; + if (TVMFFIFunctionCall(mhc_pre_big_fuse_with_norm_tilelang_kernel_packed, (TVMFFIAny*) stack_ffi_any, 15, &result_88) != 0) { + return -1; + } + return 0; +} + +// CodegenC: NOTE: Auto-generated entry function +#ifdef __cplusplus +extern "C" +#endif +int32_t __tvm_ffi_main(void* self, void* args,int num_args, void* result) { + return __tvm_ffi_mhc_pre_big_fuse_with_norm_tilelang(self, args, num_args, result); +} diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/ee551f0fd55a5f344ee5ec2ee5aa79c7656eb4c9efbd0c4a7c2d3107c1e82478/params.pkl b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/ee551f0fd55a5f344ee5ec2ee5aa79c7656eb4c9efbd0c4a7c2d3107c1e82478/params.pkl new file mode 100644 index 0000000..456ab98 Binary files /dev/null and b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/runtime/cache/tilelang/cache/0.1.9-x86_64/kernels/ee551f0fd55a5f344ee5ec2ee5aa79c7656eb4c9efbd0c4a7c2d3107c1e82478/params.pkl differ diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/start_vllm_docker.sh b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/start_vllm_docker.sh new file mode 100755 index 0000000..4aa90c2 --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/start_vllm_docker.sh @@ -0,0 +1,117 @@ +#!/usr/bin/env bash +# Start vLLM server in Docker for a given TPxDP configuration. +# Usage: start_vllm_docker.sh +# +# Uses the vllm/vllm-openai image and the same argument set as the +# bare-metal start script. The container is removed automatically on stop. +set -e + +TP="${1}" +DP="${2}" + +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +# shellcheck source=/dev/null +source "${SCRIPT_DIR}/config.env" + +RUNTIME_BASE="${RUNTIME_BASE:-${SCRIPT_DIR}/runtime}" +mkdir -p "${RUNTIME_BASE}/logs" "${RUNTIME_BASE}/tmp" + +# Persistent kernel caches on the host so TileLang/DeepGEMM JIT compilation +# survives container restarts (each TP×DP config starts a fresh container). +CACHE_DIR="${RUNTIME_BASE}/cache" +mkdir -p "${CACHE_DIR}/tilelang" "${CACHE_DIR}/deep_gemm" + +IMAGE="${DOCKER_IMAGE:-vllm/vllm-openai:latest}" +PORT="${VLLM_PORT:-30032}" +NAME="${EXPERIMENT}_vllm_tp${TP}_dp${DP}" +PID_FILE="${RUNTIME_BASE}/${EXPERIMENT}_vllm_tp${TP}_dp${DP}.pid" + +LOG="${RUNTIME_BASE}/logs/${EXPERIMENT}_vllm_docker_tp${TP}_dp${DP}_$(date +%Y%m%d_%H%M%S).log" +rm -f "$PID_FILE" + +# Clean up any stale container with the same name. +docker rm -f "$NAME" >/dev/null 2>&1 || true + +SERVER_ARGS=( + "$MODEL_PATH" + --trust-remote-code + --kv-cache-dtype "$KV_CACHE_DTYPE" + --block-size "$BLOCK_SIZE" + --tensor-parallel-size "$TP" + --gpu-memory-utilization "$GPU_MEMORY_UTILIZATION" + --max-model-len "$MAX_MODEL_LEN" + --max-num-seqs "$MAX_NUM_SEQS" + --no-enable-flashinfer-autotune + --tokenizer-mode "$TOKENIZER_MODE" + --reasoning-parser "$REASONING_PARSER" + --spec-method "$SPEC_METHOD" + --spec-model "$MODEL_PATH" + --spec-tokens "$SPEC_TOKENS" + --no-disable-hybrid-kv-cache-manager + --disable-uvicorn-access-log + --host 0.0.0.0 + --port "$PORT" +) + +if [[ "$DP" -gt 1 ]]; then + SERVER_ARGS+=( + --data-parallel-size "$DP" + ) +fi + +SERVER_ARGS_STR="${SERVER_ARGS[*]}" + +echo "=== Starting vLLM server in Docker (TP=${TP}, DP=${DP}) ===" +echo "Image: $IMAGE" +echo "Model: $MODEL_PATH" +echo "Container name: $NAME" +echo "Host port: $PORT" +echo "Command: vllm ${SERVER_ARGS_STR}" +echo "Log: $LOG" + +# Run docker in the foreground so that killing the host process stops the +# container (the --rm flag ensures cleanup). nohup lets us background it and +# capture the host PID in the same way as the bare-metal start script. +nohup docker run --rm \ + --name "$NAME" \ + --gpus all \ + --ipc host \ + --shm-size 16g \ + --ulimit memlock=-1 \ + -p "${PORT}:${PORT}" \ + -v "${MODEL_PATH}:${MODEL_PATH}:ro" \ + -v "${RUNTIME_BASE}/tmp:/tmp" \ + -v "${CACHE_DIR}/tilelang:/root/.tilelang" \ + -v "${CACHE_DIR}/deep_gemm:/root/.cache/deep_gemm" \ + -e CUDA_VISIBLE_DEVICES="${CUDA_VISIBLE_DEVICES}" \ + -e PYTHONUNBUFFERED=1 \ + -e HF_HUB_OFFLINE=1 \ + -e TRANSFORMERS_OFFLINE=1 \ + -e VLLM_ENGINE_READY_TIMEOUT_S="${VLLM_ENGINE_READY_TIMEOUT_S:-3600}" \ + "$IMAGE" \ + "${SERVER_ARGS[@]}" \ + > "$LOG" 2>&1 & + +PID=$! +echo $PID > "$PID_FILE" +echo "PID: $PID" +echo "Waiting for health on port ${PORT}..." + +for i in $(seq 1 "${HEALTH_CHECK_RETRIES:-720}"); do + if curl --fail --silent --show-error --max-time 5 "http://127.0.0.1:${PORT}/health" >/dev/null 2>&1; then + echo "vLLM server is ready at http://127.0.0.1:${PORT}" + echo "Log: $LOG" + exit 0 + fi + if ! kill -0 $PID 2>/dev/null; then + echo "ERROR: Docker vLLM server exited early" + tail -200 "$LOG" + exit 1 + fi + echo "Waiting... ($i/${HEALTH_CHECK_RETRIES:-720})" + sleep 5 +done + +echo "ERROR: Docker vLLM server not healthy after ${HEALTH_CHECK_RETRIES:-720} retries" +tail -200 "$LOG" +exit 1 diff --git a/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/start_vllm_dp.sh b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/start_vllm_dp.sh new file mode 100755 index 0000000..ba00bfb --- /dev/null +++ b/experiments/h20/dsv4_dspark_h20_vllm_tp_dp_matrix/start_vllm_dp.sh @@ -0,0 +1,95 @@ +#!/usr/bin/env bash +# Start vLLM server for a given TP×DP configuration. +# Usage: start_vllm_dp.sh +# +# By default this delegates to the Docker start script because the experiment +# is intended to run vLLM inside a container. Set USE_DOCKER=0 to use the +# local VENV_VLLM environment instead. +set -e + +TP="${1}" +DP="${2}" + +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +# shellcheck source=/dev/null +source "${SCRIPT_DIR}/config.env" + +if [[ "${USE_DOCKER:-1}" == "1" ]]; then + exec "${SCRIPT_DIR}/start_vllm_docker.sh" "$@" +fi + +RUNTIME_BASE="${RUNTIME_BASE:-${SCRIPT_DIR}/runtime}" +mkdir -p "${RUNTIME_BASE}/logs" "${RUNTIME_BASE}/tmp" + +VENV="${VENV_VLLM}" +export PATH="$VENV/bin:$PATH" +export PYTHONUNBUFFERED=1 +export TMPDIR="${RUNTIME_BASE}/tmp" +export CUDA_VISIBLE_DEVICES="${CUDA_VISIBLE_DEVICES}" +export VLLM_ENGINE_READY_TIMEOUT_S="${VLLM_ENGINE_READY_TIMEOUT_S:-3600}" + +LOG="${RUNTIME_BASE}/logs/${EXPERIMENT}_vllm_tp${TP}_dp${DP}_$(date +%Y%m%d_%H%M%S).log" +PID_FILE="${RUNTIME_BASE}/${EXPERIMENT}_vllm_tp${TP}_dp${DP}.pid" + +rm -f "$PID_FILE" + +SERVER_ARGS=( + vllm serve "$MODEL_PATH" + --trust-remote-code + --kv-cache-dtype "$KV_CACHE_DTYPE" + --block-size "$BLOCK_SIZE" + --tensor-parallel-size "$TP" + --gpu-memory-utilization "$GPU_MEMORY_UTILIZATION" + --max-model-len "$MAX_MODEL_LEN" + --max-num-seqs "$MAX_NUM_SEQS" + --no-enable-flashinfer-autotune + --tokenizer-mode "$TOKENIZER_MODE" + --reasoning-parser "$REASONING_PARSER" + --spec-method "$SPEC_METHOD" + --spec-model "$MODEL_PATH" + --spec-tokens "$SPEC_TOKENS" + --no-disable-hybrid-kv-cache-manager + --disable-uvicorn-access-log + --host 0.0.0.0 + --port "$VLLM_PORT" +) + +if [[ "$DP" -gt 1 ]]; then + SERVER_ARGS+=( + --data-parallel-size "$DP" + ) +fi + +SERVER_ARGS_STR="${SERVER_ARGS[*]}" + +echo "=== Starting vLLM server (TP=${TP}, DP=${DP}) ===" +echo "Model: $MODEL_PATH" +echo "Port: $VLLM_PORT" +echo "Command: $SERVER_ARGS_STR" +echo "Log: $LOG" + +nohup "${SERVER_ARGS[@]}" > "$LOG" 2>&1 & + +PID=$! +echo $PID > "$PID_FILE" +echo "PID: $PID" +echo "Waiting for health on port ${VLLM_PORT}..." + +for i in $(seq 1 "${HEALTH_CHECK_RETRIES:-720}"); do + if curl --fail --silent --show-error --max-time 5 "http://127.0.0.1:${VLLM_PORT}/health" >/dev/null 2>&1; then + echo "vLLM server is ready at http://127.0.0.1:${VLLM_PORT}" + echo "Log: $LOG" + exit 0 + fi + if ! kill -0 $PID 2>/dev/null; then + echo "ERROR: vLLM server exited early" + tail -200 "$LOG" + exit 1 + fi + echo "Waiting... ($i/${HEALTH_CHECK_RETRIES:-720})" + sleep 5 +done + +echo "ERROR: vLLM server not healthy after ${HEALTH_CHECK_RETRIES:-720} retries" +tail -200 "$LOG" +exit 1 diff --git a/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023330/adaptive_points.jsonl b/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023330/adaptive_points.jsonl new file mode 100644 index 0000000..e69de29 diff --git a/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023330/adaptive_shapes.jsonl b/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023330/adaptive_shapes.jsonl new file mode 100644 index 0000000..e69de29 diff --git a/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023330/run_manifest.json b/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023330/run_manifest.json new file mode 100644 index 0000000..9b3e26b --- /dev/null +++ b/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023330/run_manifest.json @@ -0,0 +1,27 @@ +{ + "experiment": "dsv4_h20_sglang_tp_dp_matrix", + "engine": "sglang", + "run_id": "adaptive_20260717-023330", + "model": "/data1/hf_models/DeepSeek-V4-Flash", + "hardware": "8x NVIDIA H20 96GB", + "matrix": "/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/matrix.json", + "dataset": "random", + "tokenize_prompt": false, + "random_range_ratio": 1.0, + "search": { + "start_concurrency": 16, + "max_concurrency": 512, + "multiplier": 2, + "initial_backoff_concurrencies": [ + 8, + 1 + ], + "num_prompts_multiplier": 5, + "min_tps_gain_pct": 2.0, + "plateau_patience": 2, + "warmup_max_requests": 0, + "ttft_slo_ms": 4000.0, + "enable_ttft_slo_stop": 1, + "ttft_group_skip_ms": 8000.0 + } +} diff --git a/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023330/shapes.tsv b/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023330/shapes.tsv new file mode 100644 index 0000000..121a236 --- /dev/null +++ b/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023330/shapes.tsv @@ -0,0 +1,29 @@ +mark input_len output_len +Y 1024 128 +Y 1024 256 +Y 1024 512 +Y 1024 1024 +Y 1024 2048 +Y 1024 4096 +Y 4096 128 +Y 4096 256 +Y 4096 512 +Y 4096 1024 +Y 4096 2048 +Y 4096 4096 +Y 16384 128 +Y 16384 256 +Y 16384 512 +Y 16384 1024 +Y 16384 2048 +Y 65536 128 +Y 65536 256 +Y 65536 512 +Y 65536 1024 +Y 131072 128 +Y 131072 256 +Y 131072 512 +Y 262144 128 +Y 262144 256 +Y 524288 128 +Y 1048576 128 diff --git a/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/adaptive_points.jsonl b/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/adaptive_points.jsonl new file mode 100644 index 0000000..97c6b84 --- /dev/null +++ b/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/adaptive_points.jsonl @@ -0,0 +1,306 @@ +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":14.319155801989837,"request_tps":5.586921541064798,"input_tps":5721.007658050353,"output_tps":715.1259572562941,"total_tps":6436.133615306647,"mean_input_tokens":1024.0,"mean_output_tokens":128.0,"ttft_p50_ms":277.4286990024848,"ttft_p95_ms":1215.3485399365306,"ttft_p99_ms":1532.7667899173684,"tpot_p50_ms":17.72723445661025,"tpot_p95_ms":22.490902544390206,"tpot_p99_ms":24.51078795776592,"e2e_p50_ms":2575.730904994998,"e2e_p95_ms":3700.7338890791275,"e2e_p99_ms":4118.3772813063115,"itl_p50_ms":12.196033509098925,"itl_p95_ms":18.98693994735366,"itl_p99_ms":199.37408544559727,"validation_errors":[],"timestamp":"2026-07-17T02:52:26+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":128,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c16_i1024_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c16_i1024_o128_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":17.254682720988058,"request_tps":9.272845092966039,"input_tps":9495.393375197224,"output_tps":1186.924171899653,"total_tps":10682.317547096876,"mean_input_tokens":1024.0,"mean_output_tokens":128.0,"ttft_p50_ms":539.6478890033904,"ttft_p95_ms":1009.1634355994756,"ttft_p99_ms":1041.7306197070866,"tpot_p50_ms":20.930400941045185,"tpot_p95_ms":32.519491238603884,"tpot_p99_ms":34.22209420914012,"e2e_p50_ms":3267.6170310005546,"e2e_p95_ms":4677.964394204896,"e2e_p99_ms":5258.394049518974,"itl_p50_ms":15.53124948986806,"itl_p95_ms":21.648424403974722,"itl_p99_ms":202.3492483142765,"validation_errors":[],"timestamp":"2026-07-17T02:53:23+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":128,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":65.974142,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c32_i1024_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c32_i1024_o128_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":21.280536325008143,"request_tps":11.277911248785605,"input_tps":11548.58111875646,"output_tps":1443.5726398445574,"total_tps":12992.153758601016,"mean_input_tokens":1024.0,"mean_output_tokens":128.0,"ttft_p50_ms":476.00927550229244,"ttft_p95_ms":985.5550944892456,"ttft_p99_ms":1013.2169248379068,"tpot_p50_ms":26.194980326883208,"tpot_p95_ms":41.62610146052279,"tpot_p99_ms":45.31596837789424,"e2e_p50_ms":4001.544553990243,"e2e_p95_ms":5745.095741766271,"e2e_p99_ms":6203.753936047433,"itl_p50_ms":18.47137049480807,"itl_p95_ms":67.50340379803674,"itl_p99_ms":233.1394106114748,"validation_errors":[],"timestamp":"2026-07-17T02:54:29+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":128,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":21.622988,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c48_i1024_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c48_i1024_o128_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":23.402349828975275,"request_tps":13.673840547575983,"input_tps":14002.012720717807,"output_tps":1750.2515900897258,"total_tps":15752.264310807534,"mean_input_tokens":1024.0,"mean_output_tokens":128.0,"ttft_p50_ms":772.5403249933152,"ttft_p95_ms":1012.4636577063939,"ttft_p99_ms":1204.5455823416708,"tpot_p50_ms":27.587484692908113,"tpot_p95_ms":48.13685582450676,"tpot_p99_ms":53.455933542332275,"e2e_p50_ms":4136.969338011113,"e2e_p95_ms":6650.728189261281,"e2e_p99_ms":7470.980764408014,"itl_p50_ms":21.13232399278786,"itl_p95_ms":45.32625950669167,"itl_p99_ms":226.53947820275792,"validation_errors":[],"timestamp":"2026-07-17T02:55:30+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":128,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":21.244442,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c64_i1024_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c64_i1024_o128_a1.log"} +{"status":"COMPLETED","completed":400,"failed":0,"duration_s":27.957149349997053,"request_tps":14.30761037158612,"input_tps":14650.993020504187,"output_tps":1831.3741275630234,"total_tps":16482.36714806721,"mean_input_tokens":1024.0,"mean_output_tokens":128.0,"ttft_p50_ms":607.550839020405,"ttft_p95_ms":1244.140784823684,"ttft_p99_ms":1381.3470771722496,"tpot_p50_ms":38.09354481102595,"tpot_p95_ms":55.6555941767049,"tpot_p99_ms":60.27480064053913,"e2e_p50_ms":5434.924501998466,"e2e_p95_ms":7445.155506736773,"e2e_p99_ms":8120.7490637328,"itl_p50_ms":24.984126503113657,"itl_p95_ms":111.58734815835487,"itl_p99_ms":351.67041263805015,"validation_errors":[],"timestamp":"2026-07-17T02:56:35+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":128,"concurrency":80,"num_prompts":400,"warmup_requests":80,"attempt":1,"gain_pct":4.634907,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c80_i1024_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c80_i1024_o128_a1.log"} +{"status":"COMPLETED","completed":480,"failed":0,"duration_s":30.643348843004787,"request_tps":15.664084315953398,"input_tps":16040.02233953628,"output_tps":2005.002792442035,"total_tps":18045.025131978316,"mean_input_tokens":1024.0,"mean_output_tokens":128.0,"ttft_p50_ms":694.2494190006983,"ttft_p95_ms":1349.0151780031736,"ttft_p99_ms":1372.8061693024938,"tpot_p50_ms":39.82938223623388,"tpot_p95_ms":63.019703439754,"tpot_p99_ms":68.01101756166649,"e2e_p50_ms":5856.150324994815,"e2e_p95_ms":8368.987591940091,"e2e_p99_ms":9208.225811893353,"itl_p50_ms":25.425028492463753,"itl_p95_ms":120.03782969695746,"itl_p99_ms":415.13216641236767,"validation_errors":[],"timestamp":"2026-07-17T02:57:43+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":128,"concurrency":96,"num_prompts":480,"warmup_requests":96,"attempt":1,"gain_pct":9.480786,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c96_i1024_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c96_i1024_o128_a1.log"} +{"status":"COMPLETED","completed":560,"failed":0,"duration_s":36.491950781986816,"request_tps":15.34584992031798,"input_tps":15714.150318405611,"output_tps":1964.2687898007014,"total_tps":17678.41910820631,"mean_input_tokens":1024.0,"mean_output_tokens":128.0,"ttft_p50_ms":562.7291694981977,"ttft_p95_ms":1566.0253147085311,"ttft_p99_ms":1737.3475803105976,"tpot_p50_ms":44.91855309440619,"tpot_p95_ms":75.05598394734157,"tpot_p99_ms":77.95829026361719,"e2e_p50_ms":6881.094816984842,"e2e_p95_ms":9953.462196253531,"e2e_p99_ms":10370.103250034732,"itl_p50_ms":28.837517485953867,"itl_p95_ms":181.74861914012584,"itl_p99_ms":467.1624144550878,"validation_errors":[],"timestamp":"2026-07-17T02:58:58+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":128,"concurrency":112,"num_prompts":560,"warmup_requests":112,"attempt":1,"gain_pct":-2.031618,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c112_i1024_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c112_i1024_o128_a1.log"} +{"status":"COMPLETED","completed":640,"failed":0,"duration_s":30.442801123019308,"request_tps":21.023032585397154,"input_tps":21527.585367446685,"output_tps":2690.9481709308357,"total_tps":24218.533538377524,"mean_input_tokens":1024.0,"mean_output_tokens":128.0,"ttft_p50_ms":1457.9174450045684,"ttft_p95_ms":2429.2581760397297,"ttft_p99_ms":2656.931013420981,"tpot_p50_ms":32.81410309446217,"tpot_p95_ms":53.52902224330473,"tpot_p99_ms":58.960238663041075,"e2e_p50_ms":5579.431209509494,"e2e_p95_ms":8215.684824081836,"e2e_p99_ms":8429.606479987851,"itl_p50_ms":29.000874506891705,"itl_p95_ms":32.72024715115549,"itl_p99_ms":159.15959559148368,"validation_errors":[],"timestamp":"2026-07-17T03:00:14+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":128,"concurrency":128,"num_prompts":640,"warmup_requests":128,"attempt":1,"gain_pct":36.994905,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c128_i1024_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c128_i1024_o128_a1.log"} +{"status":"COMPLETED","completed":720,"failed":0,"duration_s":35.96413516899338,"request_tps":20.01994477600426,"input_tps":20500.42345062836,"output_tps":2562.552931328545,"total_tps":23062.976381956905,"mean_input_tokens":1024.0,"mean_output_tokens":128.0,"ttft_p50_ms":936.6897555009928,"ttft_p95_ms":1830.8229967573425,"ttft_p99_ms":1870.8153823862083,"tpot_p50_ms":44.69157159445335,"tpot_p95_ms":71.68012291682729,"tpot_p99_ms":75.10565235001754,"e2e_p50_ms":6655.6145814975025,"e2e_p95_ms":9641.245345113566,"e2e_p99_ms":10078.138926478568,"itl_p50_ms":31.899202993372455,"itl_p95_ms":108.31547359994175,"itl_p99_ms":593.5030251712305,"validation_errors":[],"timestamp":"2026-07-17T03:01:29+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":128,"concurrency":144,"num_prompts":720,"warmup_requests":144,"attempt":1,"gain_pct":-4.771375,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c144_i1024_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c144_i1024_o128_a1.log"} +{"status":"COMPLETED","completed":800,"failed":0,"duration_s":44.102117549977265,"request_tps":18.139718554181133,"input_tps":18575.07179948148,"output_tps":2321.883974935185,"total_tps":20896.955774416667,"mean_input_tokens":1024.0,"mean_output_tokens":128.0,"ttft_p50_ms":616.5119064971805,"ttft_p95_ms":2130.0171388400486,"ttft_p99_ms":2370.7282493278035,"tpot_p50_ms":55.06490055903862,"tpot_p95_ms":102.33878888543623,"tpot_p99_ms":107.0364238634338,"e2e_p50_ms":8202.999429006013,"e2e_p95_ms":13469.1625061183,"e2e_p99_ms":14074.366920616594,"itl_p50_ms":32.24658650287893,"itl_p95_ms":219.6956996107474,"itl_p99_ms":456.34816816891544,"validation_errors":[],"timestamp":"2026-07-17T03:02:57+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":128,"concurrency":160,"num_prompts":800,"warmup_requests":160,"attempt":1,"gain_pct":-9.391765,"plateau_streak":2,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c160_i1024_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c160_i1024_o128_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":19.46471912699053,"request_tps":4.110000225437053,"input_tps":4208.640230847543,"output_tps":1052.1600577118857,"total_tps":5260.800288559428,"mean_input_tokens":1024.0,"mean_output_tokens":256.0,"ttft_p50_ms":299.2731039994396,"ttft_p95_ms":455.01345088850934,"ttft_p99_ms":480.46308959426773,"tpot_p50_ms":13.85741416660512,"tpot_p95_ms":14.800409923761846,"tpot_p99_ms":15.384627398885284,"e2e_p50_ms":3881.309770498774,"e2e_p95_ms":4163.371754754917,"e2e_p99_ms":4181.618606077682,"itl_p50_ms":12.139992002630606,"itl_p95_ms":12.579699407797307,"itl_p99_ms":48.36695765436138,"validation_errors":[],"timestamp":"2026-07-17T03:03:55+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":256,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c16_i1024_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c16_i1024_o256_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":26.900463705998845,"request_tps":5.947852860407003,"input_tps":6090.601329056771,"output_tps":1522.6503322641927,"total_tps":7613.251661320964,"mean_input_tokens":1024.0,"mean_output_tokens":256.0,"ttft_p50_ms":332.5567874999251,"ttft_p95_ms":632.3516210963126,"ttft_p99_ms":703.0743372323922,"tpot_p50_ms":19.19821243329138,"tpot_p95_ms":22.520847096097626,"tpot_p99_ms":23.043789315259986,"e2e_p50_ms":5278.719677502522,"e2e_p95_ms":6103.323892295884,"e2e_p99_ms":6323.756253347383,"itl_p50_ms":15.521130015258677,"itl_p95_ms":19.678625171945892,"itl_p99_ms":149.62694910820576,"validation_errors":[],"timestamp":"2026-07-17T03:05:00+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":256,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":44.716607,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c32_i1024_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c32_i1024_o256_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":31.654808847000822,"request_tps":7.581786424931741,"input_tps":7763.749299130102,"output_tps":1940.9373247825256,"total_tps":9704.686623912628,"mean_input_tokens":1024.0,"mean_output_tokens":256.0,"ttft_p50_ms":484.404878487112,"ttft_p95_ms":834.5039631065446,"ttft_p99_ms":898.7586289612226,"tpot_p50_ms":21.746887760773284,"tpot_p95_ms":27.802548673136304,"tpot_p99_ms":30.947371048803724,"e2e_p50_ms":5908.628926990787,"e2e_p95_ms":7654.046678628947,"e2e_p99_ms":8390.642906484427,"itl_p50_ms":18.44529549998697,"itl_p95_ms":21.616246135090474,"itl_p99_ms":173.5544421587838,"validation_errors":[],"timestamp":"2026-07-17T03:06:12+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":256,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":27.470982,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c48_i1024_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c48_i1024_o256_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":37.67653590699774,"request_tps":8.49334983422841,"input_tps":8697.190230249891,"output_tps":2174.297557562473,"total_tps":10871.487787812364,"mean_input_tokens":1024.0,"mean_output_tokens":256.0,"ttft_p50_ms":384.0604469878599,"ttft_p95_ms":953.6505392665276,"ttft_p99_ms":1026.1496138796792,"tpot_p50_ms":24.933406623541465,"tpot_p95_ms":35.9163621962801,"tpot_p99_ms":38.58816530121098,"e2e_p50_ms":6843.690871508443,"e2e_p95_ms":9587.575324534555,"e2e_p99_ms":10417.733214693146,"itl_p50_ms":21.070865506771952,"itl_p95_ms":30.390144583361693,"itl_p99_ms":199.88251058908554,"validation_errors":[],"timestamp":"2026-07-17T03:07:29+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":256,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":12.023069,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c64_i1024_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c64_i1024_o256_a1.log"} +{"status":"COMPLETED","completed":400,"failed":0,"duration_s":39.99099268601276,"request_tps":10.002252335684178,"input_tps":10242.306391740598,"output_tps":2560.5765979351495,"total_tps":12802.882989675747,"mean_input_tokens":1024.0,"mean_output_tokens":256.0,"ttft_p50_ms":510.030421501142,"ttft_p95_ms":1136.5529578499263,"ttft_p99_ms":1196.0567368741613,"tpot_p50_ms":28.123323996060567,"tpot_p95_ms":32.1810767706826,"tpot_p99_ms":32.66092622160282,"e2e_p50_ms":7830.465641513001,"e2e_p95_ms":8666.572467485094,"e2e_p99_ms":8734.41734349326,"itl_p50_ms":24.991041005705483,"itl_p95_ms":28.09102284518303,"itl_p99_ms":159.30826613621318,"validation_errors":[],"timestamp":"2026-07-17T03:08:54+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":256,"concurrency":80,"num_prompts":400,"warmup_requests":80,"attempt":1,"gain_pct":17.765694,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c80_i1024_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c80_i1024_o256_a1.log"} +{"status":"COMPLETED","completed":480,"failed":0,"duration_s":47.775353281002026,"request_tps":10.047021466838071,"input_tps":10288.149982042185,"output_tps":2572.0374955105463,"total_tps":12860.18747755273,"mean_input_tokens":1024.0,"mean_output_tokens":256.0,"ttft_p50_ms":460.4134085093392,"ttft_p95_ms":1317.021268128883,"ttft_p99_ms":1366.2930329653318,"tpot_p50_ms":32.57025655686591,"tpot_p95_ms":47.38687584628052,"tpot_p99_ms":50.16615744963444,"e2e_p50_ms":8815.04510648665,"e2e_p95_ms":12626.149212018936,"e2e_p99_ms":13262.517469126615,"itl_p50_ms":25.356750513310544,"itl_p95_ms":63.30344528978454,"itl_p99_ms":216.80429791362246,"validation_errors":[],"timestamp":"2026-07-17T03:10:24+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":256,"concurrency":96,"num_prompts":480,"warmup_requests":96,"attempt":1,"gain_pct":0.44759,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c96_i1024_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c96_i1024_o256_a1.log"} +{"status":"COMPLETED","completed":560,"failed":0,"duration_s":49.39242540401756,"request_tps":11.337770830635295,"input_tps":11609.877330570542,"output_tps":2902.4693326426354,"total_tps":14512.346663213179,"mean_input_tokens":1024.0,"mean_output_tokens":256.0,"ttft_p50_ms":744.0177199896425,"ttft_p95_ms":1523.758915849612,"ttft_p99_ms":1550.3369767413824,"tpot_p50_ms":35.04400501174934,"tpot_p95_ms":42.58128224309379,"tpot_p99_ms":44.12046441820326,"e2e_p50_ms":9628.06157200248,"e2e_p95_ms":11520.589660591213,"e2e_p99_ms":11903.375085401349,"itl_p50_ms":28.908698994200677,"itl_p95_ms":38.162315702356814,"itl_p99_ms":175.0409514148491,"validation_errors":[],"timestamp":"2026-07-17T03:11:56+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":256,"concurrency":112,"num_prompts":560,"warmup_requests":112,"attempt":1,"gain_pct":12.847085,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c112_i1024_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c112_i1024_o256_a1.log"} +{"status":"COMPLETED","completed":640,"failed":0,"duration_s":49.97527613802231,"request_tps":12.806332439913698,"input_tps":13113.684418471626,"output_tps":3278.4211046179066,"total_tps":16392.105523089533,"mean_input_tokens":1024.0,"mean_output_tokens":256.0,"ttft_p50_ms":550.3324669989524,"ttft_p95_ms":1678.0456714739555,"ttft_p99_ms":1739.2549631168367,"tpot_p50_ms":36.54797703921383,"tpot_p95_ms":41.7363808486113,"tpot_p99_ms":44.71423537201961,"e2e_p50_ms":10086.351079502492,"e2e_p95_ms":10918.843941188243,"e2e_p99_ms":12061.407890499688,"itl_p50_ms":28.943179509951733,"itl_p95_ms":40.70559861575011,"itl_p99_ms":214.06233812653227,"validation_errors":[],"timestamp":"2026-07-17T03:13:24+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":256,"concurrency":128,"num_prompts":640,"warmup_requests":128,"attempt":1,"gain_pct":12.952825,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c128_i1024_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c128_i1024_o256_a1.log"} +{"status":"COMPLETED","completed":720,"failed":0,"duration_s":54.615337289025774,"request_tps":13.1831100152278,"input_tps":13499.504655593268,"output_tps":3374.876163898317,"total_tps":16874.380819491584,"mean_input_tokens":1024.0,"mean_output_tokens":256.0,"ttft_p50_ms":645.5192850116873,"ttft_p95_ms":1812.707160877471,"ttft_p99_ms":1864.5113516552371,"tpot_p50_ms":39.451971784286556,"tpot_p95_ms":44.578568357563405,"tpot_p99_ms":45.9600443081718,"e2e_p50_ms":10859.877285489347,"e2e_p95_ms":11848.116313458013,"e2e_p99_ms":12302.738569386129,"itl_p50_ms":31.859730515861884,"itl_p95_ms":48.54930530564161,"itl_p99_ms":195.9821029094748,"validation_errors":[],"timestamp":"2026-07-17T03:14:56+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":256,"concurrency":144,"num_prompts":720,"warmup_requests":144,"attempt":1,"gain_pct":2.942119,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c144_i1024_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c144_i1024_o256_a1.log"} +{"status":"COMPLETED","completed":800,"failed":0,"duration_s":56.78414896200411,"request_tps":14.088438668602796,"input_tps":14426.561196649263,"output_tps":3606.640299162316,"total_tps":18033.20149581158,"mean_input_tokens":1024.0,"mean_output_tokens":256.0,"ttft_p50_ms":693.3235354954377,"ttft_p95_ms":1986.550270106818,"ttft_p99_ms":2062.4621730388026,"tpot_p50_ms":40.68168920976129,"tpot_p95_ms":50.22438905785067,"tpot_p99_ms":58.10713993481191,"e2e_p50_ms":11074.31951048784,"e2e_p95_ms":13087.391298814318,"e2e_p99_ms":15494.505574268987,"itl_p50_ms":31.911646990920417,"itl_p95_ms":48.26379008736693,"itl_p99_ms":257.65364312566857,"validation_errors":[],"timestamp":"2026-07-17T03:16:34+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":256,"concurrency":160,"num_prompts":800,"warmup_requests":160,"attempt":1,"gain_pct":6.867337,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c160_i1024_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c160_i1024_o256_a1.log"} +{"status":"COMPLETED","completed":880,"failed":0,"duration_s":61.14218466100283,"request_tps":14.392681662899001,"input_tps":14738.106022808577,"output_tps":3684.5265057021443,"total_tps":18422.63252851072,"mean_input_tokens":1024.0,"mean_output_tokens":256.0,"ttft_p50_ms":1074.3458090000786,"ttft_p95_ms":2121.6786339573446,"ttft_p99_ms":2147.603141121799,"tpot_p50_ms":42.18086107256229,"tpot_p95_ms":53.02733710642867,"tpot_p99_ms":55.76183981231104,"e2e_p50_ms":11822.464566488634,"e2e_p95_ms":14081.71025308693,"e2e_p99_ms":14604.861543969018,"itl_p50_ms":34.6874579845462,"itl_p95_ms":42.54445154074346,"itl_p99_ms":201.82632602663944,"validation_errors":[],"timestamp":"2026-07-17T03:18:15+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":256,"concurrency":176,"num_prompts":880,"warmup_requests":176,"attempt":1,"gain_pct":2.159522,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c176_i1024_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c176_i1024_o256_a1.log"} +{"status":"COMPLETED","completed":960,"failed":0,"duration_s":65.10078059401712,"request_tps":14.746366959664776,"input_tps":15100.27976669673,"output_tps":3775.0699416741827,"total_tps":18875.349708370915,"mean_input_tokens":1024.0,"mean_output_tokens":256.0,"ttft_p50_ms":951.9808314944385,"ttft_p95_ms":2299.0732784499414,"ttft_p99_ms":2337.676192933577,"tpot_p50_ms":44.20576487455571,"tpot_p95_ms":63.341520717846876,"tpot_p99_ms":65.69127907200064,"e2e_p50_ms":12136.35394499579,"e2e_p95_ms":16566.042724531133,"e2e_p99_ms":17799.088942515664,"itl_p50_ms":34.75537600752432,"itl_p95_ms":53.782740030145845,"itl_p99_ms":334.68502053874624,"validation_errors":[],"timestamp":"2026-07-17T03:20:00+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":256,"concurrency":192,"num_prompts":960,"warmup_requests":192,"attempt":1,"gain_pct":2.457397,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c192_i1024_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c192_i1024_o256_a1.log"} +{"status":"COMPLETED","completed":1040,"failed":0,"duration_s":67.15418443098315,"request_tps":15.486749021110466,"input_tps":15858.430997617117,"output_tps":3964.6077494042793,"total_tps":19823.038747021397,"mean_input_tokens":1024.0,"mean_output_tokens":256.0,"ttft_p50_ms":1007.0786154974485,"ttft_p95_ms":2531.571320448711,"ttft_p99_ms":2569.4173997777393,"tpot_p50_ms":45.969452778409305,"tpot_p95_ms":58.290396426158374,"tpot_p99_ms":61.553469696158636,"e2e_p50_ms":13205.155149509665,"e2e_p95_ms":15394.693685350647,"e2e_p99_ms":16043.639874742656,"itl_p50_ms":37.4148429982597,"itl_p95_ms":50.287285748345276,"itl_p99_ms":264.01417432905873,"validation_errors":[],"timestamp":"2026-07-17T03:21:47+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":256,"concurrency":208,"num_prompts":1040,"warmup_requests":208,"attempt":1,"gain_pct":5.020776,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c208_i1024_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c208_i1024_o256_a1.log"} +{"status":"COMPLETED","completed":1120,"failed":0,"duration_s":72.4681152900157,"request_tps":15.455072834691315,"input_tps":15825.994582723906,"output_tps":3956.4986456809766,"total_tps":19782.493228404885,"mean_input_tokens":1024.0,"mean_output_tokens":256.0,"ttft_p50_ms":752.6263445179211,"ttft_p95_ms":2638.587307995476,"ttft_p99_ms":2681.292440473917,"tpot_p50_ms":50.49392257842199,"tpot_p95_ms":72.96092037561203,"tpot_p99_ms":80.78721015048258,"e2e_p50_ms":13748.564601512044,"e2e_p95_ms":19099.756566983706,"e2e_p99_ms":21158.308162351892,"itl_p50_ms":37.550775494310074,"itl_p95_ms":113.2391552062472,"itl_p99_ms":458.1956554271165,"validation_errors":[],"timestamp":"2026-07-17T03:23:39+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":256,"concurrency":224,"num_prompts":1120,"warmup_requests":224,"attempt":1,"gain_pct":-0.204537,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c224_i1024_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c224_i1024_o256_a1.log"} +{"status":"COMPLETED","completed":1200,"failed":0,"duration_s":76.23055609301082,"request_tps":15.741719088810658,"input_tps":16119.520346942114,"output_tps":4029.8800867355285,"total_tps":20149.40043367764,"mean_input_tokens":1024.0,"mean_output_tokens":256.0,"ttft_p50_ms":900.2646370063303,"ttft_p95_ms":3051.7211971382494,"ttft_p99_ms":3125.3798694949364,"tpot_p50_ms":52.0776247960634,"tpot_p95_ms":69.78318687551197,"tpot_p99_ms":75.38362491914577,"e2e_p50_ms":14175.518010990345,"e2e_p95_ms":18366.59126470622,"e2e_p99_ms":19928.17398014682,"itl_p50_ms":39.812146496842615,"itl_p95_ms":106.1041946028126,"itl_p99_ms":516.6854592121673,"validation_errors":[],"timestamp":"2026-07-17T03:25:38+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":256,"concurrency":240,"num_prompts":1200,"warmup_requests":240,"attempt":1,"gain_pct":1.854707,"plateau_streak":2,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c240_i1024_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c240_i1024_o256_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":35.073790576978354,"request_tps":2.2809054477422293,"input_tps":2335.6471784880428,"output_tps":1167.8235892440214,"total_tps":3503.4707677320644,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":216.66763151006307,"ttft_p95_ms":414.2002500157104,"ttft_p99_ms":443.0565934971673,"tpot_p50_ms":12.852383331715087,"tpot_p95_ms":14.449154953709247,"tpot_p99_ms":14.612865566504743,"e2e_p50_ms":6781.494360504439,"e2e_p95_ms":7680.311683297623,"e2e_p99_ms":7847.649814189353,"itl_p50_ms":12.139855010900646,"itl_p95_ms":12.83237611351069,"itl_p99_ms":18.811571336991605,"validation_errors":[],"timestamp":"2026-07-17T03:26:50+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":512,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c16_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c16_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":45.76550460999715,"request_tps":3.4960829420211206,"input_tps":3579.9889326296275,"output_tps":1789.9944663148137,"total_tps":5369.983398944441,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":344.2369679978583,"ttft_p95_ms":644.8817390439217,"ttft_p99_ms":662.5960547412977,"tpot_p50_ms":16.754401910000063,"tpot_p95_ms":19.68457837289048,"tpot_p99_ms":20.14563180275563,"e2e_p50_ms":8830.528429491096,"e2e_p95_ms":10348.291304007578,"e2e_p99_ms":10584.442471035,"itl_p50_ms":15.477480497793294,"itl_p95_ms":17.17842919169925,"itl_p99_ms":65.08095915749614,"validation_errors":[],"timestamp":"2026-07-17T03:28:19+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":512,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":53.276101,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c32_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c32_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":56.9556393189996,"request_tps":4.213805741970477,"input_tps":4314.937079777768,"output_tps":2157.468539888884,"total_tps":6472.405619666653,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":380.94641851785127,"ttft_p95_ms":795.3468836989487,"ttft_p99_ms":847.6608931913506,"tpot_p50_ms":19.994180441292734,"tpot_p95_ms":25.130382870034513,"tpot_p99_ms":25.4419388259176,"e2e_p50_ms":10594.968096498633,"e2e_p95_ms":13207.539431613985,"e2e_p99_ms":13491.959525423881,"itl_p50_ms":18.421669490635395,"itl_p95_ms":21.829389687627547,"itl_p99_ms":133.08502059342578,"validation_errors":[],"timestamp":"2026-07-17T03:29:53+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":512,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":20.529341,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c48_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c48_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":62.90023688701331,"request_tps":5.0874212218756965,"input_tps":5209.519331200713,"output_tps":2604.7596656003566,"total_tps":7814.27899680107,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":353.2975894922856,"ttft_p95_ms":1023.9439742261311,"ttft_p99_ms":1176.3101245232974,"tpot_p50_ms":22.99672009492518,"tpot_p95_ms":25.860316339565724,"tpot_p99_ms":26.6991339183623,"e2e_p50_ms":12445.101422505104,"e2e_p95_ms":13502.540480296013,"e2e_p99_ms":13858.808951812389,"itl_p50_ms":21.102308979607187,"itl_p95_ms":24.62766973330871,"itl_p99_ms":141.00943197903686,"validation_errors":[],"timestamp":"2026-07-17T03:31:36+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":512,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":20.73222,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c64_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c64_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":400,"failed":0,"duration_s":75.0952005989966,"request_tps":5.3265720952790785,"input_tps":5454.409825565776,"output_tps":2727.204912782888,"total_tps":8181.614738348664,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":482.98446150147356,"ttft_p95_ms":1123.4198665435542,"ttft_p99_ms":1163.2640762568917,"tpot_p50_ms":27.633237377674376,"tpot_p95_ms":32.65349999978706,"tpot_p99_ms":33.830918326709416,"e2e_p50_ms":14797.413747000974,"e2e_p95_ms":17026.60434624267,"e2e_p99_ms":17751.801187425735,"itl_p50_ms":25.018654981977306,"itl_p95_ms":28.865536807279568,"itl_p99_ms":144.7806376154771,"validation_errors":[],"timestamp":"2026-07-17T03:33:35+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":512,"concurrency":80,"num_prompts":400,"warmup_requests":80,"attempt":1,"gain_pct":4.700827,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c80_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c80_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":480,"failed":0,"duration_s":79.35203310201177,"request_tps":6.0489943513221816,"input_tps":6194.170215753914,"output_tps":3097.085107876957,"total_tps":9291.25532363087,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":464.78584299620707,"ttft_p95_ms":1306.0467857081676,"ttft_p99_ms":1379.7304429969518,"tpot_p50_ms":28.66515195888076,"tpot_p95_ms":35.51411453072984,"tpot_p99_ms":36.81922068889116,"e2e_p50_ms":15306.679571498535,"e2e_p95_ms":18406.57959106902,"e2e_p99_ms":19237.776732741913,"itl_p50_ms":25.367299516801722,"itl_p95_ms":30.951738094154276,"itl_p99_ms":168.05161260766906,"validation_errors":[],"timestamp":"2026-07-17T03:35:40+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":512,"concurrency":96,"num_prompts":480,"warmup_requests":96,"attempt":1,"gain_pct":13.562611,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c96_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c96_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":560,"failed":0,"duration_s":88.69989339800668,"request_tps":6.3134235966577235,"input_tps":6464.945762977509,"output_tps":3232.4728814887544,"total_tps":9697.418644466263,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":663.9204414968845,"ttft_p95_ms":1483.7168039302921,"ttft_p99_ms":1537.85768548114,"tpot_p50_ms":32.61987760957716,"tpot_p95_ms":38.96851164365196,"tpot_p99_ms":40.230922746116555,"e2e_p50_ms":17480.70124651713,"e2e_p95_ms":20129.03008005087,"e2e_p99_ms":20926.12659825565,"itl_p50_ms":28.93577399663627,"itl_p95_ms":33.80422322807135,"itl_p99_ms":155.5798831567517,"validation_errors":[],"timestamp":"2026-07-17T03:37:45+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":512,"concurrency":112,"num_prompts":560,"warmup_requests":112,"attempt":1,"gain_pct":4.371458,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c112_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c112_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":640,"failed":0,"duration_s":89.9566533860052,"request_tps":7.114537679094746,"input_tps":7285.28658339302,"output_tps":3642.64329169651,"total_tps":10927.92987508953,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":580.74178150855,"ttft_p95_ms":1652.9203918384155,"ttft_p99_ms":1687.821140686865,"tpot_p50_ms":33.490161670294654,"tpot_p95_ms":38.970497334445454,"tpot_p99_ms":40.34445858524507,"e2e_p50_ms":17762.63855799334,"e2e_p95_ms":20297.31250423938,"e2e_p99_ms":20972.356420661963,"itl_p50_ms":28.96841500478331,"itl_p95_ms":35.370188100205254,"itl_p99_ms":165.1946289636543,"validation_errors":[],"timestamp":"2026-07-17T03:39:58+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":512,"concurrency":128,"num_prompts":640,"warmup_requests":128,"attempt":1,"gain_pct":12.68906,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c128_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c128_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":720,"failed":0,"duration_s":98.20975099501084,"request_tps":7.331247586979187,"input_tps":7507.197529066688,"output_tps":3753.598764533344,"total_tps":11260.796293600031,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":666.7762330034748,"ttft_p95_ms":1895.894637494348,"ttft_p99_ms":1986.4238581992684,"tpot_p50_ms":36.485546071431145,"tpot_p95_ms":41.82510556980176,"tpot_p99_ms":43.10759975950526,"e2e_p50_ms":19403.995651504374,"e2e_p95_ms":21714.471528703867,"e2e_p99_ms":22577.877566107192,"itl_p50_ms":31.815789494430646,"itl_p95_ms":37.96172690636013,"itl_p99_ms":174.2101944380556,"validation_errors":[],"timestamp":"2026-07-17T03:42:19+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":512,"concurrency":144,"num_prompts":720,"warmup_requests":144,"attempt":1,"gain_pct":3.046015,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c144_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c144_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":800,"failed":0,"duration_s":100.07592101101181,"request_tps":7.993930926820772,"input_tps":8185.78526906447,"output_tps":4092.892634532235,"total_tps":12278.677903596705,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":582.0708345127059,"ttft_p95_ms":2141.2936499968055,"ttft_p99_ms":2193.836867828504,"tpot_p50_ms":36.85674197848115,"tpot_p95_ms":42.45162480225429,"tpot_p99_ms":43.70916901808551,"e2e_p50_ms":19714.543495487305,"e2e_p95_ms":22057.62081400171,"e2e_p99_ms":22594.186320737645,"itl_p50_ms":31.947305498761125,"itl_p95_ms":39.42050923069473,"itl_p99_ms":175.8940367025207,"validation_errors":[],"timestamp":"2026-07-17T03:44:38+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":512,"concurrency":160,"num_prompts":800,"warmup_requests":160,"attempt":1,"gain_pct":9.039162,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c160_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c160_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":880,"failed":0,"duration_s":108.8498252419813,"request_tps":8.084532961295015,"input_tps":8278.561752366095,"output_tps":4139.280876183047,"total_tps":12417.842628549142,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":640.2838799986057,"ttft_p95_ms":2128.8874099918758,"ttft_p99_ms":2155.0699243415147,"tpot_p50_ms":40.68439803228608,"tpot_p95_ms":45.972051706540746,"tpot_p99_ms":47.20228571528246,"e2e_p50_ms":21481.826719493256,"e2e_p95_ms":23848.246323659256,"e2e_p99_ms":24396.05003714154,"itl_p50_ms":34.856293990742415,"itl_p95_ms":43.52380880736745,"itl_p99_ms":189.20611083973262,"validation_errors":[],"timestamp":"2026-07-17T03:47:09+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":512,"concurrency":176,"num_prompts":880,"warmup_requests":176,"attempt":1,"gain_pct":1.133385,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c176_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c176_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":960,"failed":0,"duration_s":110.19855374001781,"request_tps":8.71154808678204,"input_tps":8920.625240864809,"output_tps":4460.312620432404,"total_tps":13380.937861297214,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":815.3414464904927,"ttft_p95_ms":2257.8965573571622,"ttft_p99_ms":2368.3734038178227,"tpot_p50_ms":40.588708641884644,"tpot_p95_ms":46.83951725466236,"tpot_p99_ms":49.01842580670288,"e2e_p50_ms":21710.97373550583,"e2e_p95_ms":24349.029981512285,"e2e_p99_ms":25519.825902169105,"itl_p50_ms":34.84171300078742,"itl_p95_ms":45.11227930197492,"itl_p99_ms":184.00264583760824,"validation_errors":[],"timestamp":"2026-07-17T03:49:47+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":512,"concurrency":192,"num_prompts":960,"warmup_requests":192,"attempt":1,"gain_pct":7.755737,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c192_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c192_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":1040,"failed":0,"duration_s":117.55852925000363,"request_tps":8.84665712164792,"input_tps":9058.97689256747,"output_tps":4529.488446283735,"total_tps":13588.465338851205,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":689.0322895051213,"ttft_p95_ms":2399.088680987188,"ttft_p99_ms":2431.198021965101,"tpot_p50_ms":43.485842909010756,"tpot_p95_ms":49.53539889808341,"tpot_p99_ms":50.72685553900449,"e2e_p50_ms":23411.609679998946,"e2e_p95_ms":25694.362504954915,"e2e_p99_ms":26308.930741497312,"itl_p50_ms":37.623620504746214,"itl_p95_ms":47.151115359156385,"itl_p99_ms":221.0772220953366,"validation_errors":[],"timestamp":"2026-07-17T03:52:25+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":512,"concurrency":208,"num_prompts":1040,"warmup_requests":208,"attempt":1,"gain_pct":1.550919,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c208_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c208_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":1120,"failed":0,"duration_s":118.55644198600203,"request_tps":9.446977163267421,"input_tps":9673.70461518584,"output_tps":4836.85230759292,"total_tps":14510.556922778758,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":976.0452490008902,"ttft_p95_ms":2630.3599282357027,"ttft_p99_ms":2662.0303444500314,"tpot_p50_ms":43.671252157556445,"tpot_p95_ms":48.74321357974711,"tpot_p99_ms":51.254561357048075,"e2e_p50_ms":23501.925094489707,"e2e_p95_ms":25743.052372353846,"e2e_p99_ms":26583.268012049666,"itl_p50_ms":37.597756017930806,"itl_p95_ms":47.61053050460758,"itl_p99_ms":182.09751314017905,"validation_errors":[],"timestamp":"2026-07-17T03:55:06+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":512,"concurrency":224,"num_prompts":1120,"warmup_requests":224,"attempt":1,"gain_pct":6.78584,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c224_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c224_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":1200,"failed":0,"duration_s":145.3211928580131,"request_tps":8.257570533242642,"input_tps":8455.752226040466,"output_tps":4227.876113020233,"total_tps":12683.628339060699,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":807.9745934810489,"ttft_p95_ms":4346.479684991937,"ttft_p99_ms":4996.711800368794,"tpot_p50_ms":48.800235591000025,"tpot_p95_ms":75.64275086178309,"tpot_p99_ms":82.14279400520157,"e2e_p50_ms":26483.785645497846,"e2e_p95_ms":39377.231810799276,"e2e_p99_ms":42430.36736599199,"itl_p50_ms":39.81783350172918,"itl_p95_ms":129.87488646322151,"itl_p99_ms":290.47726307239043,"validation_errors":[],"timestamp":"2026-07-17T03:58:17+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":512,"concurrency":240,"num_prompts":1200,"warmup_requests":240,"attempt":1,"gain_pct":-12.590341,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c240_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c240_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":67.35126058600144,"request_tps":1.187802563811664,"input_tps":1216.309825343144,"output_tps":1216.309825343144,"total_tps":2432.619650686288,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":271.3983755093068,"ttft_p95_ms":872.7231357770506,"ttft_p99_ms":885.5345840376685,"tpot_p50_ms":12.733348118285702,"tpot_p95_ms":13.292780874325414,"tpot_p99_ms":13.440798128684966,"e2e_p50_ms":13373.686150996946,"e2e_p95_ms":14097.9435441026,"e2e_p99_ms":14122.959846788144,"itl_p50_ms":12.138917998527177,"itl_p95_ms":12.545658116869163,"itl_p99_ms":15.409495247004088,"validation_errors":[],"timestamp":"2026-07-17T04:00:07+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":1024,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c16_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c16_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":86.57755494199228,"request_tps":1.8480540378762302,"input_tps":1892.4073347852598,"output_tps":1892.4073347852598,"total_tps":3784.8146695705195,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":344.5699309959309,"ttft_p95_ms":628.5211490932852,"ttft_p99_ms":644.6776387799764,"tpot_p50_ms":16.262036129041487,"tpot_p95_ms":17.6216721259025,"tpot_p99_ms":17.83597014385015,"e2e_p50_ms":17048.65177499596,"e2e_p95_ms":18383.410959440513,"e2e_p99_ms":18678.060564682528,"itl_p50_ms":15.444608987309039,"itl_p95_ms":16.862740262877182,"itl_p99_ms":24.680859597574393,"validation_errors":[],"timestamp":"2026-07-17T04:02:14+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":1024,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":55.585961,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c32_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c32_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":103.87712478500907,"request_tps":2.310422053909557,"input_tps":2365.872183203386,"output_tps":2365.872183203386,"total_tps":4731.744366406772,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":336.1459315055981,"ttft_p95_ms":789.2782978960894,"ttft_p99_ms":854.2625880852573,"tpot_p50_ms":19.461471652995588,"tpot_p95_ms":21.572803517440022,"tpot_p99_ms":21.891628302395524,"e2e_p50_ms":20345.050365503994,"e2e_p95_ms":22397.623136387847,"e2e_p99_ms":22702.630040096992,"itl_p50_ms":18.406058487016708,"itl_p95_ms":21.076221573457588,"itl_p99_ms":55.66825373069134,"validation_errors":[],"timestamp":"2026-07-17T04:04:34+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":1024,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":25.019183,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c48_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c48_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":119.30600101599703,"request_tps":2.682178576726355,"input_tps":2746.5508625677876,"output_tps":2746.5508625677876,"total_tps":5493.101725135575,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":444.33186600508634,"ttft_p95_ms":957.9311055509606,"ttft_p99_ms":1003.0537926257239,"tpot_p50_ms":22.29995030546989,"tpot_p95_ms":25.16462414266189,"tpot_p99_ms":25.457115626326882,"e2e_p50_ms":23209.389797004405,"e2e_p95_ms":26128.189869264315,"e2e_p99_ms":26470.7228899232,"itl_p50_ms":21.023755500209518,"itl_p95_ms":24.808399086759884,"itl_p99_ms":72.17314954032126,"validation_errors":[],"timestamp":"2026-07-17T04:07:14+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":1024,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":16.090416,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c64_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c64_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":400,"failed":0,"duration_s":142.3325214809738,"request_tps":2.8103204793815846,"input_tps":2877.7681708867426,"output_tps":2877.7681708867426,"total_tps":5755.536341773485,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":351.06272299890406,"ttft_p95_ms":1433.8150609008153,"ttft_p99_ms":1537.4392922993866,"tpot_p50_ms":26.51514166324886,"tpot_p95_ms":29.913282000289826,"tpot_p99_ms":30.611950500552414,"e2e_p50_ms":27958.618885997566,"e2e_p95_ms":30861.719508642273,"e2e_p99_ms":31593.76633418171,"itl_p50_ms":24.937779497122392,"itl_p95_ms":29.720182016899326,"itl_p99_ms":128.11383763299094,"validation_errors":[],"timestamp":"2026-07-17T04:10:20+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":1024,"concurrency":80,"num_prompts":400,"warmup_requests":80,"attempt":1,"gain_pct":4.777531,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c80_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c80_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":480,"failed":0,"duration_s":145.47569552398636,"request_tps":3.2995202275616995,"input_tps":3378.7087130231803,"output_tps":3378.7087130231803,"total_tps":6757.417426046361,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":475.4323255037889,"ttft_p95_ms":1309.2158859188203,"ttft_p99_ms":1374.604946266918,"tpot_p50_ms":27.35039123900363,"tpot_p95_ms":30.11237908137827,"tpot_p99_ms":30.808103929509286,"e2e_p50_ms":28737.37127048662,"e2e_p95_ms":31199.803193382104,"e2e_p99_ms":31773.384057306394,"itl_p50_ms":25.37896049034316,"itl_p95_ms":31.00988919904921,"itl_p99_ms":122.43695561599428,"validation_errors":[],"timestamp":"2026-07-17T04:13:23+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":1024,"concurrency":96,"num_prompts":480,"warmup_requests":96,"attempt":1,"gain_pct":17.407258,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c96_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c96_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":560,"failed":0,"duration_s":165.00094025800354,"request_tps":3.3939200535727654,"input_tps":3475.3741348585118,"output_tps":3475.3741348585118,"total_tps":6950.7482697170235,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":415.8967580005992,"ttft_p95_ms":1526.7102184981923,"ttft_p99_ms":1561.5319260509568,"tpot_p50_ms":31.024309063538773,"tpot_p95_ms":34.66530657088987,"tpot_p99_ms":36.33262579338672,"e2e_p50_ms":32348.670134000713,"e2e_p95_ms":35701.156244358564,"e2e_p99_ms":37465.066965092265,"itl_p50_ms":28.832614989369176,"itl_p95_ms":34.54497955099214,"itl_p99_ms":139.9669663986423,"validation_errors":[],"timestamp":"2026-07-17T04:16:50+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":1024,"concurrency":112,"num_prompts":560,"warmup_requests":112,"attempt":1,"gain_pct":2.861017,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c112_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c112_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":640,"failed":0,"duration_s":167.46633111999836,"request_tps":3.821663708279407,"input_tps":3913.383637278113,"output_tps":3913.383637278113,"total_tps":7826.767274556226,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":479.82906199467834,"ttft_p95_ms":1657.7925413817864,"ttft_p99_ms":1688.1955430211383,"tpot_p50_ms":31.40552994280606,"tpot_p95_ms":35.45668263910149,"tpot_p99_ms":36.396600701156004,"e2e_p50_ms":32871.66052599787,"e2e_p95_ms":36805.83563290129,"e2e_p99_ms":37700.78737948672,"itl_p50_ms":28.976568006328307,"itl_p95_ms":35.4270648138481,"itl_p99_ms":144.13592554716126,"validation_errors":[],"timestamp":"2026-07-17T04:20:17+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":1024,"concurrency":128,"num_prompts":640,"warmup_requests":128,"attempt":1,"gain_pct":12.603233,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c128_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c128_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":720,"failed":0,"duration_s":182.03788713901304,"request_tps":3.9552205934480704,"input_tps":4050.145887690824,"output_tps":4050.145887690824,"total_tps":8100.291775381648,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":512.6569835119881,"ttft_p95_ms":1813.136863699765,"ttft_p99_ms":1860.8122903009644,"tpot_p50_ms":34.590237273698996,"tpot_p95_ms":37.83671790274474,"tpot_p99_ms":38.6194702869648,"e2e_p50_ms":36102.62511300971,"e2e_p95_ms":38962.813909351826,"e2e_p99_ms":39847.250948559085,"itl_p50_ms":31.841220494243316,"itl_p95_ms":38.76831473608035,"itl_p99_ms":142.1156534631155,"validation_errors":[],"timestamp":"2026-07-17T04:24:03+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":1024,"concurrency":144,"num_prompts":720,"warmup_requests":144,"attempt":1,"gain_pct":3.494731,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c144_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c144_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":800,"failed":0,"duration_s":185.16419090499403,"request_tps":4.320489810097635,"input_tps":4424.181565539979,"output_tps":4424.181565539979,"total_tps":8848.363131079957,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":482.8032460063696,"ttft_p95_ms":2002.0903128170175,"ttft_p99_ms":2052.3590867919847,"tpot_p50_ms":35.51161228836731,"tpot_p95_ms":38.06873964316505,"tpot_p99_ms":38.540041214774924,"e2e_p50_ms":37090.86491599737,"e2e_p95_ms":39256.08978858654,"e2e_p99_ms":39674.440955645405,"itl_p50_ms":31.895760985207744,"itl_p95_ms":39.84115798521087,"itl_p99_ms":160.2747862844263,"validation_errors":[],"timestamp":"2026-07-17T04:27:49+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":1024,"concurrency":160,"num_prompts":800,"warmup_requests":160,"attempt":1,"gain_pct":9.235116,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c160_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c160_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":880,"failed":0,"duration_s":200.25991599197732,"request_tps":4.394289269727118,"input_tps":4499.7522122005685,"output_tps":4499.7522122005685,"total_tps":8999.504424401137,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":492.3115775163751,"ttft_p95_ms":2132.514526012528,"ttft_p99_ms":2183.822453011526,"tpot_p50_ms":38.08368966618099,"tpot_p95_ms":41.439516664631334,"tpot_p99_ms":42.450637040081524,"e2e_p50_ms":39635.20813899231,"e2e_p95_ms":42646.31205444748,"e2e_p99_ms":43726.68739257759,"itl_p50_ms":34.736770001472905,"itl_p95_ms":43.54952974681509,"itl_p99_ms":158.89704165630963,"validation_errors":[],"timestamp":"2026-07-17T04:31:54+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":1024,"concurrency":176,"num_prompts":880,"warmup_requests":176,"attempt":1,"gain_pct":1.708127,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c176_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c176_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":960,"failed":0,"duration_s":202.79978802599362,"request_tps":4.733732758522179,"input_tps":4847.342344726711,"output_tps":4847.342344726711,"total_tps":9694.684689453423,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":505.24608450359665,"ttft_p95_ms":2331.613764257054,"ttft_p99_ms":2384.3385003862204,"tpot_p50_ms":38.47752110019234,"tpot_p95_ms":41.90648779701653,"tpot_p99_ms":44.24762427539827,"e2e_p50_ms":40189.86142100766,"e2e_p95_ms":43167.031224911625,"e2e_p99_ms":45618.582891682454,"itl_p50_ms":34.857625505537726,"itl_p95_ms":44.42366840667091,"itl_p99_ms":159.0937938817657,"validation_errors":[],"timestamp":"2026-07-17T04:36:07+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":1024,"concurrency":192,"num_prompts":960,"warmup_requests":192,"attempt":1,"gain_pct":7.724651,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c192_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c192_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":1040,"failed":0,"duration_s":214.99499654001556,"request_tps":4.837321876029947,"input_tps":4953.417601054665,"output_tps":4953.417601054665,"total_tps":9906.83520210933,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":757.8366884990828,"ttft_p95_ms":2412.3721884170664,"ttft_p99_ms":2448.1162663720893,"tpot_p50_ms":40.611653612908505,"tpot_p95_ms":43.7385136430743,"tpot_p99_ms":44.793683515090876,"e2e_p50_ms":42781.118710001465,"e2e_p95_ms":45100.36008051247,"e2e_p99_ms":46215.676186810306,"itl_p50_ms":37.609007995342836,"itl_p95_ms":46.472527393780176,"itl_p99_ms":140.53120419441285,"validation_errors":[],"timestamp":"2026-07-17T04:40:25+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":1024,"concurrency":208,"num_prompts":1040,"warmup_requests":208,"attempt":1,"gain_pct":2.188318,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c208_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c208_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":1120,"failed":0,"duration_s":219.20359891399858,"request_tps":5.109405162820416,"input_tps":5232.0308867281055,"output_tps":5232.0308867281055,"total_tps":10464.061773456211,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":741.594620005344,"ttft_p95_ms":2626.263974912581,"ttft_p99_ms":2665.1359040715033,"tpot_p50_ms":41.31073976882491,"tpot_p95_ms":45.445633964744914,"tpot_p99_ms":46.82299969858002,"e2e_p50_ms":43399.30184200057,"e2e_p95_ms":46937.841678106626,"e2e_p99_ms":48295.15845260146,"itl_p50_ms":37.700935994507745,"itl_p95_ms":47.17392304737587,"itl_p99_ms":153.9074900816194,"validation_errors":[],"timestamp":"2026-07-17T04:44:55+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":1024,"concurrency":224,"num_prompts":1120,"warmup_requests":224,"attempt":1,"gain_pct":5.624668,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c224_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c224_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":1200,"failed":0,"duration_s":246.52045146899763,"request_tps":4.86775029353259,"input_tps":4984.576300577372,"output_tps":4984.576300577372,"total_tps":9969.152601154745,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":992.5127094902564,"ttft_p95_ms":4279.201637714868,"ttft_p99_ms":4473.631566499826,"tpot_p50_ms":44.352445756606414,"tpot_p95_ms":56.00517298239907,"tpot_p99_ms":60.412836060837066,"e2e_p50_ms":46538.26830499747,"e2e_p95_ms":58805.64902534388,"e2e_p99_ms":62716.211966384144,"itl_p50_ms":39.78985350113362,"itl_p95_ms":53.53463633364299,"itl_p99_ms":171.11717915220657,"validation_errors":[],"timestamp":"2026-07-17T04:49:49+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":1024,"concurrency":240,"num_prompts":1200,"warmup_requests":240,"attempt":1,"gain_pct":-4.729609,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c240_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c240_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":130.28304875901085,"request_tps":0.6140476505733207,"input_tps":628.7847941870804,"output_tps":1257.5695883741607,"total_tps":1886.3543825612412,"mean_input_tokens":1024.0,"mean_output_tokens":2048.0,"ttft_p50_ms":268.70773400878534,"ttft_p95_ms":871.1318174566259,"ttft_p99_ms":876.9353907075129,"tpot_p50_ms":12.469071889104576,"tpot_p95_ms":12.843627527108872,"tpot_p99_ms":12.933953634900476,"e2e_p50_ms":25916.510707495036,"e2e_p95_ms":26766.183238333906,"e2e_p99_ms":26776.731204502867,"itl_p50_ms":12.17404600174632,"itl_p95_ms":12.816560966894029,"itl_p99_ms":15.049547585949774,"validation_errors":[],"timestamp":"2026-07-17T04:52:42+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":2048,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c16_i1024_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c16_i1024_o2048_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":167.3057054390083,"request_tps":0.9563331960506773,"input_tps":979.2851927558936,"output_tps":1958.5703855117872,"total_tps":2937.855578267681,"mean_input_tokens":1024.0,"mean_output_tokens":2048.0,"ttft_p50_ms":291.3887899921974,"ttft_p95_ms":630.6089556135702,"ttft_p99_ms":643.7550996875507,"tpot_p50_ms":15.940716932593121,"tpot_p95_ms":16.927677187182574,"tpot_p99_ms":17.094408375148134,"e2e_p50_ms":33132.504675508244,"e2e_p95_ms":35025.35115778592,"e2e_p99_ms":35261.65447234962,"itl_p50_ms":15.463286996237002,"itl_p95_ms":17.66273919783998,"itl_p99_ms":20.459449674235653,"validation_errors":[],"timestamp":"2026-07-17T04:56:05+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":2048,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":55.742506,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c32_i1024_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c32_i1024_o2048_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":199.4843546379998,"request_tps":1.2031018694950946,"input_tps":1231.9763143629768,"output_tps":2463.9526287259537,"total_tps":3695.9289430889307,"mean_input_tokens":1024.0,"mean_output_tokens":2048.0,"ttft_p50_ms":332.1479184960481,"ttft_p95_ms":769.8991353521704,"ttft_p99_ms":789.3987737011048,"tpot_p50_ms":18.980454134345763,"tpot_p95_ms":20.271033450706216,"tpot_p99_ms":20.415485021121945,"e2e_p50_ms":39290.67898000358,"e2e_p95_ms":41812.611177212966,"e2e_p99_ms":42077.97931449837,"itl_p50_ms":18.39544800168369,"itl_p95_ms":21.34158721164567,"itl_p99_ms":27.084546800470033,"validation_errors":[],"timestamp":"2026-07-17T05:00:02+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":2048,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":25.803629,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c48_i1024_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c48_i1024_o2048_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":228.45736080600182,"request_tps":1.4006990139036626,"input_tps":1434.3157902373505,"output_tps":2868.631580474701,"total_tps":4302.947370712051,"mean_input_tokens":1024.0,"mean_output_tokens":2048.0,"ttft_p50_ms":338.4495359932771,"ttft_p95_ms":960.5192310365966,"ttft_p99_ms":974.5951437033364,"tpot_p50_ms":21.72655227918983,"tpot_p95_ms":23.258865641116206,"tpot_p99_ms":23.822227267427138,"e2e_p50_ms":45087.416912501794,"e2e_p95_ms":47909.13708198641,"e2e_p99_ms":49011.92389970034,"itl_p50_ms":21.03414550947491,"itl_p95_ms":25.472643393732135,"itl_p99_ms":37.340177050500635,"validation_errors":[],"timestamp":"2026-07-17T05:04:34+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":2048,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":16.423975,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c64_i1024_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c64_i1024_o2048_a1.log"} +{"status":"COMPLETED","completed":400,"failed":0,"duration_s":269.6722507849918,"request_tps":1.4832820167282166,"input_tps":1518.8807851296938,"output_tps":3037.7615702593876,"total_tps":4556.642355389082,"mean_input_tokens":1024.0,"mean_output_tokens":2048.0,"ttft_p50_ms":367.9683364898665,"ttft_p95_ms":1113.7739013371174,"ttft_p99_ms":1135.7328094402328,"tpot_p50_ms":25.76619340157318,"tpot_p95_ms":27.39219644135246,"tpot_p99_ms":27.952403432586696,"e2e_p50_ms":53489.545163,"e2e_p95_ms":56320.67548699414,"e2e_p99_ms":57611.19537717488,"itl_p50_ms":24.890556014725007,"itl_p95_ms":29.167355909885355,"itl_p99_ms":42.64691574207974,"validation_errors":[],"timestamp":"2026-07-17T05:09:47+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":2048,"concurrency":80,"num_prompts":400,"warmup_requests":80,"attempt":1,"gain_pct":5.895842,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c80_i1024_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c80_i1024_o2048_a1.log"} +{"status":"COMPLETED","completed":480,"failed":0,"duration_s":277.1382875860145,"request_tps":1.7319873200523548,"input_tps":1773.5550157336113,"output_tps":3547.1100314672226,"total_tps":5320.665047200834,"mean_input_tokens":1024.0,"mean_output_tokens":2048.0,"ttft_p50_ms":374.85248601296917,"ttft_p95_ms":1361.2065883469766,"ttft_p99_ms":1408.773693498224,"tpot_p50_ms":26.730106835371885,"tpot_p95_ms":28.015165695847276,"tpot_p99_ms":28.2464888330554,"e2e_p50_ms":55096.050383494,"e2e_p95_ms":57577.24440121382,"e2e_p99_ms":58042.20309246535,"itl_p50_ms":25.290881996625103,"itl_p95_ms":30.96823655214393,"itl_p99_ms":58.87953876983444,"validation_errors":[],"timestamp":"2026-07-17T05:15:07+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":2048,"concurrency":96,"num_prompts":480,"warmup_requests":96,"attempt":1,"gain_pct":16.76723,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c96_i1024_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c96_i1024_o2048_a1.log"} +{"status":"COMPLETED","completed":560,"failed":0,"duration_s":311.7467427070078,"request_tps":1.7963299155504269,"input_tps":1839.4418335236371,"output_tps":3678.8836670472742,"total_tps":5518.325500570912,"mean_input_tokens":1024.0,"mean_output_tokens":2048.0,"ttft_p50_ms":414.55427499022335,"ttft_p95_ms":1431.8773012695601,"ttft_p99_ms":1484.0879805793518,"tpot_p50_ms":29.796473479728327,"tpot_p95_ms":31.490323958182056,"tpot_p99_ms":31.664708942579065,"e2e_p50_ms":61695.23806399957,"e2e_p95_ms":64796.91381810262,"e2e_p99_ms":65245.76555710838,"itl_p50_ms":28.552356001455337,"itl_p95_ms":34.11358435987495,"itl_p99_ms":67.05840561160635,"validation_errors":[],"timestamp":"2026-07-17T05:21:02+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":2048,"concurrency":112,"num_prompts":560,"warmup_requests":112,"attempt":1,"gain_pct":3.714958,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c112_i1024_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c112_i1024_o2048_a1.log"} +{"status":"COMPLETED","completed":640,"failed":0,"duration_s":313.9314334119845,"request_tps":2.0386617327360876,"input_tps":2087.5896143217537,"output_tps":4175.1792286435075,"total_tps":6262.768842965262,"mean_input_tokens":1024.0,"mean_output_tokens":2048.0,"ttft_p50_ms":604.5890740060713,"ttft_p95_ms":1583.1098085138365,"ttft_p99_ms":1647.4907687591622,"tpot_p50_ms":29.999193440408522,"tpot_p95_ms":31.84509006016288,"tpot_p99_ms":32.15983410823508,"e2e_p50_ms":62086.81861498917,"e2e_p95_ms":65700.24230425333,"e2e_p99_ms":66165.57810439961,"itl_p50_ms":28.807255512219854,"itl_p95_ms":42.31697220966457,"itl_p99_ms":106.00913995964213,"validation_errors":[],"timestamp":"2026-07-17T05:26:58+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":2048,"concurrency":128,"num_prompts":640,"warmup_requests":128,"attempt":1,"gain_pct":13.490385,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c128_i1024_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c128_i1024_o2048_a1.log"} +{"status":"COMPLETED","completed":720,"failed":0,"duration_s":345.65169096700265,"request_tps":2.0830217783275193,"input_tps":2133.01430100738,"output_tps":4266.02860201476,"total_tps":6399.042903022139,"mean_input_tokens":1024.0,"mean_output_tokens":2048.0,"ttft_p50_ms":463.338860499789,"ttft_p95_ms":1822.3600891084059,"ttft_p99_ms":1853.2579392657499,"tpot_p50_ms":33.137289305561005,"tpot_p95_ms":34.75556589352611,"tpot_p99_ms":34.937888092227915,"e2e_p50_ms":68626.51722101145,"e2e_p95_ms":71579.89874982886,"e2e_p99_ms":72588.21806990483,"itl_p50_ms":31.698361999588087,"itl_p95_ms":56.56825355108596,"itl_p99_ms":135.59028794377826,"validation_errors":[],"timestamp":"2026-07-17T05:33:33+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":2048,"concurrency":144,"num_prompts":720,"warmup_requests":144,"attempt":1,"gain_pct":2.175939,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c144_i1024_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c144_i1024_o2048_a1.log"} +{"status":"COMPLETED","completed":800,"failed":0,"duration_s":342.95661777598434,"request_tps":2.332656547606122,"input_tps":2388.6403047486688,"output_tps":4777.2806094973375,"total_tps":7165.920914246007,"mean_input_tokens":1024.0,"mean_output_tokens":2048.0,"ttft_p50_ms":1630.6768625072436,"ttft_p95_ms":4052.153384681151,"ttft_p99_ms":4619.2986949082115,"tpot_p50_ms":32.33637246384728,"tpot_p95_ms":33.604507537396984,"tpot_p99_ms":33.817688460555296,"e2e_p50_ms":67848.60337598366,"e2e_p95_ms":70272.75117129319,"e2e_p99_ms":70517.3060541987,"itl_p50_ms":31.52950300136581,"itl_p95_ms":59.1364492313005,"itl_p99_ms":207.774984734715,"validation_errors":[],"timestamp":"2026-07-17T05:40:07+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":2048,"concurrency":160,"num_prompts":800,"warmup_requests":160,"attempt":1,"gain_pct":11.984261,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c160_i1024_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c160_i1024_o2048_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":253.4061495680071,"request_tps":0.3156987316068675,"input_tps":323.27550116543233,"output_tps":1293.1020046617293,"total_tps":1616.3775058271617,"mean_input_tokens":1024.0,"mean_output_tokens":4096.0,"ttft_p50_ms":190.59207852114923,"ttft_p95_ms":366.19021338701714,"ttft_p99_ms":393.54146413796065,"tpot_p50_ms":12.23592302515069,"tpot_p95_ms":12.449379082042022,"tpot_p99_ms":12.559081982805235,"e2e_p50_ms":50356.46153248672,"e2e_p95_ms":51281.334167768364,"e2e_p99_ms":51633.76050397812,"itl_p50_ms":12.170039000920951,"itl_p95_ms":13.013108698942231,"itl_p99_ms":15.172267672314774,"validation_errors":[],"timestamp":"2026-07-17T05:45:01+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":4096,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c16_i1024_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c16_i1024_o4096_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":323.9156192499795,"request_tps":0.49395580358389934,"input_tps":505.81074286991293,"output_tps":2023.2429714796517,"total_tps":2529.053714349565,"mean_input_tokens":1024.0,"mean_output_tokens":4096.0,"ttft_p50_ms":220.00811800535303,"ttft_p95_ms":629.1705287832883,"ttft_p99_ms":643.4671894757776,"tpot_p50_ms":15.61613188290648,"tpot_p95_ms":15.979946446300485,"tpot_p99_ms":16.15108628989958,"e2e_p50_ms":64146.48566300457,"e2e_p95_ms":65774.3595472042,"e2e_p99_ms":66335.0718755828,"itl_p50_ms":15.412008011480793,"itl_p95_ms":17.811850945872717,"itl_p99_ms":22.234805068583242,"validation_errors":[],"timestamp":"2026-07-17T05:51:04+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":4096,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":56.464298,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c32_i1024_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c32_i1024_o4096_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":387.41467717601336,"request_tps":0.6194912432059493,"input_tps":634.3590330428921,"output_tps":2537.4361321715683,"total_tps":3171.79516521446,"mean_input_tokens":1024.0,"mean_output_tokens":4096.0,"ttft_p50_ms":393.71715250308625,"ttft_p95_ms":1041.9243071897652,"ttft_p99_ms":1104.6109662344677,"tpot_p50_ms":18.616725027720957,"tpot_p95_ms":19.235263992490356,"tpot_p99_ms":19.31111529223362,"e2e_p50_ms":76736.39685199305,"e2e_p95_ms":78960.27020113105,"e2e_p99_ms":79747.41488991713,"itl_p50_ms":18.280382500961423,"itl_p95_ms":23.89376208302565,"itl_p99_ms":106.35599296627335,"validation_errors":[],"timestamp":"2026-07-17T05:58:15+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":4096,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":25.414306,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c48_i1024_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c48_i1024_o4096_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":440.27437913499307,"request_tps":0.726819490674665,"input_tps":744.263158450857,"output_tps":2977.052633803428,"total_tps":3721.3157922542846,"mean_input_tokens":1024.0,"mean_output_tokens":4096.0,"ttft_p50_ms":454.7764859889867,"ttft_p95_ms":968.8849987578578,"ttft_p99_ms":1036.811995638127,"tpot_p50_ms":21.213357549817278,"tpot_p95_ms":21.794373502807936,"tpot_p99_ms":21.916413746659558,"e2e_p50_ms":87325.90298949799,"e2e_p95_ms":89726.48673309159,"e2e_p99_ms":90237.94478495256,"itl_p50_ms":20.821490499656647,"itl_p95_ms":26.33668286289322,"itl_p99_ms":99.53442127181918,"validation_errors":[],"timestamp":"2026-07-17T06:06:24+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":4096,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":17.325224,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c64_i1024_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c64_i1024_o4096_a1.log"} +{"status":"COMPLETED","completed":400,"failed":0,"duration_s":522.7272340839845,"request_tps":0.7652174478740351,"input_tps":783.582666623012,"output_tps":3134.330666492048,"total_tps":3917.91333311506,"mean_input_tokens":1024.0,"mean_output_tokens":4096.0,"ttft_p50_ms":505.3371255053207,"ttft_p95_ms":1215.6720478102213,"ttft_p99_ms":1231.7670077446382,"tpot_p50_ms":25.15669708290582,"tpot_p95_ms":25.90581871650853,"tpot_p99_ms":26.27252810842735,"e2e_p50_ms":103711.87572450435,"e2e_p95_ms":106777.11650119309,"e2e_p99_ms":108511.50279717316,"itl_p50_ms":24.573448492446914,"itl_p95_ms":48.97552598995384,"itl_p99_ms":229.03921778633963,"validation_errors":[],"timestamp":"2026-07-17T06:15:51+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":4096,"concurrency":80,"num_prompts":400,"warmup_requests":80,"attempt":1,"gain_pct":5.283011,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c80_i1024_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c80_i1024_o4096_a1.log"} +{"status":"COMPLETED","completed":480,"failed":0,"duration_s":534.5436669970222,"request_tps":0.8979621865067834,"input_tps":919.5132789829462,"output_tps":3678.0531159317848,"total_tps":4597.566394914731,"mean_input_tokens":1024.0,"mean_output_tokens":4096.0,"ttft_p50_ms":752.8099725022912,"ttft_p95_ms":1365.9155263565478,"ttft_p99_ms":1648.3083841812913,"tpot_p50_ms":25.77281304615492,"tpot_p95_ms":26.84021440831409,"tpot_p99_ms":27.435723565158167,"e2e_p50_ms":106380.22096599161,"e2e_p95_ms":110311.25037439924,"e2e_p99_ms":113076.02176222601,"itl_p50_ms":24.299078999320045,"itl_p95_ms":78.83891019009711,"itl_p99_ms":277.0953662789543,"validation_errors":[],"timestamp":"2026-07-17T06:25:31+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":4096,"concurrency":96,"num_prompts":480,"warmup_requests":96,"attempt":1,"gain_pct":17.347323,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c96_i1024_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c96_i1024_o4096_a1.log"} +{"status":"COMPLETED","completed":560,"failed":0,"duration_s":602.1746604869841,"request_tps":0.929962744608222,"input_tps":952.2818504788194,"output_tps":3809.1274019152775,"total_tps":4761.409252394097,"mean_input_tokens":1024.0,"mean_output_tokens":4096.0,"ttft_p50_ms":1003.1975515157683,"ttft_p95_ms":1484.3255712665266,"ttft_p99_ms":1584.0702952933486,"tpot_p50_ms":28.98497555384788,"tpot_p95_ms":29.985039563243614,"tpot_p99_ms":30.182399839027717,"e2e_p50_ms":119740.53939401347,"e2e_p95_ms":123968.02006721264,"e2e_p99_ms":124749.42398816609,"itl_p50_ms":27.921327520743944,"itl_p95_ms":75.03190258285015,"itl_p99_ms":239.85307510127302,"validation_errors":[],"timestamp":"2026-07-17T06:36:21+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":4096,"concurrency":112,"num_prompts":560,"warmup_requests":112,"attempt":1,"gain_pct":3.563687,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c112_i1024_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c112_i1024_o4096_a1.log"} +{"status":"COMPLETED","completed":640,"failed":0,"duration_s":621.2279000639974,"request_tps":1.0302177348024273,"input_tps":1054.9429604376855,"output_tps":4219.771841750742,"total_tps":5274.714802188428,"mean_input_tokens":1024.0,"mean_output_tokens":4096.0,"ttft_p50_ms":983.5742289869813,"ttft_p95_ms":1740.1493804587517,"ttft_p99_ms":2042.894614051038,"tpot_p50_ms":29.908438747375893,"tpot_p95_ms":30.745540261280343,"tpot_p99_ms":31.032965152592922,"e2e_p50_ms":123641.66279000347,"e2e_p95_ms":127150.63983843283,"e2e_p99_ms":128362.60306155018,"itl_p50_ms":27.716479016817175,"itl_p95_ms":109.43849589530134,"itl_p99_ms":272.30561343661975,"validation_errors":[],"timestamp":"2026-07-17T06:47:33+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":4096,"concurrency":128,"num_prompts":640,"warmup_requests":128,"attempt":1,"gain_pct":10.780538,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c128_i1024_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c128_i1024_o4096_a1.log"} +{"status":"COMPLETED","completed":720,"failed":0,"duration_s":692.8450810239883,"request_tps":1.0391933488737166,"input_tps":1064.1339892466858,"output_tps":4256.535956986743,"total_tps":5320.669946233429,"mean_input_tokens":1024.0,"mean_output_tokens":4096.0,"ttft_p50_ms":1316.2317965034163,"ttft_p95_ms":2354.6858096393403,"ttft_p99_ms":2750.390632333,"tpot_p50_ms":33.31158469572606,"tpot_p95_ms":34.16991434328368,"tpot_p99_ms":34.51843496431733,"e2e_p50_ms":137936.7052424932,"e2e_p95_ms":141285.2276294987,"e2e_p99_ms":143051.6005758155,"itl_p50_ms":29.886999502195977,"itl_p95_ms":156.81636771914773,"itl_p99_ms":308.4064949466846,"validation_errors":[],"timestamp":"2026-07-17T06:59:52+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":4096,"concurrency":144,"num_prompts":720,"warmup_requests":144,"attempt":1,"gain_pct":0.871235,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c144_i1024_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c144_i1024_o4096_a1.log"} +{"status":"COMPLETED","completed":800,"failed":0,"duration_s":715.6162323099852,"request_tps":1.117917626627371,"input_tps":1144.7476496664278,"output_tps":4578.990598665711,"total_tps":5723.738248332139,"mean_input_tokens":1024.0,"mean_output_tokens":4096.0,"ttft_p50_ms":1473.6605799989775,"ttft_p95_ms":2969.293176998325,"ttft_p99_ms":3306.817113224242,"tpot_p50_ms":34.26994756959357,"tpot_p95_ms":35.834071553319774,"tpot_p99_ms":36.05412194869057,"e2e_p50_ms":141560.04667349043,"e2e_p95_ms":148473.40430149925,"e2e_p99_ms":148742.76405400218,"itl_p50_ms":29.530325511586852,"itl_p95_ms":151.5985924983393,"itl_p99_ms":342.1602821763369,"validation_errors":[],"timestamp":"2026-07-17T07:12:36+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":4096,"concurrency":160,"num_prompts":800,"warmup_requests":160,"attempt":1,"gain_pct":7.575518,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c160_i1024_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c160_i1024_o4096_a1.log"} +{"status":"COMPLETED","completed":880,"failed":0,"duration_s":793.2439389729989,"request_tps":1.109368703326398,"input_tps":1135.9935522062315,"output_tps":4543.974208824926,"total_tps":5679.967761031156,"mean_input_tokens":1024.0,"mean_output_tokens":4096.0,"ttft_p50_ms":1467.2791140037589,"ttft_p95_ms":3087.3392198540378,"ttft_p99_ms":3490.3159987498684,"tpot_p50_ms":37.895757661903815,"tpot_p95_ms":39.814047532505995,"tpot_p99_ms":40.116891495405866,"e2e_p50_ms":156707.31324599183,"e2e_p95_ms":164522.7918929697,"e2e_p99_ms":165771.03741396888,"itl_p50_ms":30.771058998652734,"itl_p95_ms":183.60982116573695,"itl_p99_ms":409.74690910079147,"validation_errors":[],"timestamp":"2026-07-17T07:26:43+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":4096,"concurrency":176,"num_prompts":880,"warmup_requests":176,"attempt":1,"gain_pct":-0.764719,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c176_i1024_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c176_i1024_o4096_a1.log"} +{"status":"COMPLETED","completed":960,"failed":0,"duration_s":797.1832929129887,"request_tps":1.2042399891398408,"input_tps":1233.141748879197,"output_tps":4932.566995516788,"total_tps":6165.7087443959845,"mean_input_tokens":1024.0,"mean_output_tokens":4096.0,"ttft_p50_ms":1631.4721410017228,"ttft_p95_ms":3140.9331073460626,"ttft_p99_ms":3908.5801401696517,"tpot_p50_ms":38.2028207763113,"tpot_p95_ms":39.39634622556636,"tpot_p99_ms":39.62702890828773,"e2e_p50_ms":157951.2082380097,"e2e_p95_ms":162672.66017543734,"e2e_p99_ms":163821.49565513013,"itl_p50_ms":24.39376449910924,"itl_p95_ms":219.4459412363353,"itl_p99_ms":414.70220797986246,"validation_errors":[],"timestamp":"2026-07-17T07:40:52+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":4096,"concurrency":192,"num_prompts":960,"warmup_requests":192,"attempt":1,"gain_pct":8.551826,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c192_i1024_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c192_i1024_o4096_a1.log"} +{"status":"COMPLETED","completed":1040,"failed":0,"duration_s":890.5485492910084,"request_tps":1.1678195431658098,"input_tps":1195.8472122017893,"output_tps":4783.388848807157,"total_tps":5979.236061008945,"mean_input_tokens":1024.0,"mean_output_tokens":4096.0,"ttft_p50_ms":2019.6398605039576,"ttft_p95_ms":3719.612761156167,"ttft_p99_ms":4333.422455885738,"tpot_p50_ms":42.7887972714297,"tpot_p95_ms":43.90111457405388,"tpot_p99_ms":44.26262737033749,"e2e_p50_ms":177530.51497999695,"e2e_p95_ms":181643.07380342216,"e2e_p99_ms":183515.58495531091,"itl_p50_ms":0.29289949452504516,"itl_p95_ms":371.2428712067776,"itl_p99_ms":598.5759714696894,"validation_errors":[],"timestamp":"2026-07-17T07:56:39+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":4096,"concurrency":208,"num_prompts":1040,"warmup_requests":208,"attempt":1,"gain_pct":-3.024351,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c208_i1024_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c208_i1024_o4096_a1.log"} +{"status":"COMPLETED","completed":1120,"failed":0,"duration_s":920.8997643349867,"request_tps":1.2162018532047192,"input_tps":1245.3906976816324,"output_tps":4981.56279072653,"total_tps":6226.953488408162,"mean_input_tokens":1024.0,"mean_output_tokens":4096.0,"ttft_p50_ms":2560.5377674946794,"ttft_p95_ms":4237.376103982388,"ttft_p99_ms":4794.8309853856335,"tpot_p50_ms":44.04458763723967,"tpot_p95_ms":44.91192443978778,"tpot_p99_ms":45.14153670107489,"e2e_p50_ms":183458.14338348282,"e2e_p95_ms":186837.6418881322,"e2e_p99_ms":187085.3472078874,"itl_p50_ms":0.2797155029838905,"itl_p95_ms":391.98247589665664,"itl_p99_ms":673.6600813592663,"validation_errors":[],"timestamp":"2026-07-17T08:12:59+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":4096,"concurrency":224,"num_prompts":1120,"warmup_requests":224,"attempt":1,"gain_pct":4.142961,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c224_i1024_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c224_i1024_o4096_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":24.772521389008034,"request_tps":3.22938463726576,"input_tps":13227.559474240554,"output_tps":413.3612335700173,"total_tps":13640.920707810572,"mean_input_tokens":4096.0,"mean_output_tokens":128.0,"ttft_p50_ms":1277.9347555042477,"ttft_p95_ms":3046.436035650549,"ttft_p99_ms":3393.156946224335,"tpot_p50_ms":27.832965204752544,"tpot_p95_ms":35.1954357712195,"tpot_p99_ms":38.72807882152133,"e2e_p50_ms":4772.0119084988255,"e2e_p95_ms":5926.885067948019,"e2e_p99_ms":7505.595177396026,"itl_p50_ms":12.248382015968673,"itl_p95_ms":32.34799010388085,"itl_p99_ms":439.1345517954322,"validation_errors":[],"timestamp":"2026-07-17T08:14:10+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":128,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c16_i4096_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c16_i4096_o128_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":29.21359407500131,"request_tps":5.4769022801242855,"input_tps":22433.391739389073,"output_tps":701.0434918559085,"total_tps":23134.43523124498,"mean_input_tokens":4096.0,"mean_output_tokens":128.0,"ttft_p50_ms":810.0483595044352,"ttft_p95_ms":1286.7606982719735,"ttft_p99_ms":1733.7996866300805,"tpot_p50_ms":40.18496422041628,"tpot_p95_ms":65.71559397088718,"tpot_p99_ms":73.09590153614063,"e2e_p50_ms":5673.400200495962,"e2e_p95_ms":9215.570432663653,"e2e_p99_ms":10416.883510008918,"itl_p50_ms":15.452328501851298,"itl_p95_ms":158.36910198850052,"itl_p99_ms":456.1020054903933,"validation_errors":[],"timestamp":"2026-07-17T08:15:23+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":128,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":69.595849,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c32_i4096_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c32_i4096_o128_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":32.37940671897377,"request_tps":7.412118513566345,"input_tps":30360.03743156775,"output_tps":948.7511697364922,"total_tps":31308.788601304244,"mean_input_tokens":4096.0,"mean_output_tokens":128.0,"ttft_p50_ms":840.2750579989515,"ttft_p95_ms":1802.829663149896,"ttft_p99_ms":2285.560088380589,"tpot_p50_ms":27.720485523564918,"tpot_p95_ms":91.83799269419863,"tpot_p99_ms":99.3164095955998,"e2e_p50_ms":4552.065051509999,"e2e_p95_ms":12468.135211792833,"e2e_p99_ms":13888.98178145288,"itl_p50_ms":18.323519005207345,"itl_p95_ms":82.88409454107746,"itl_p99_ms":738.0241876334183,"validation_errors":[],"timestamp":"2026-07-17T08:16:36+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":128,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":35.334138,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c48_i4096_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c48_i4096_o128_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":36.56047045098967,"request_tps":8.752622601751499,"input_tps":35850.74217677414,"output_tps":1120.3356930241919,"total_tps":36971.07786979833,"mean_input_tokens":4096.0,"mean_output_tokens":128.0,"ttft_p50_ms":774.8844550078502,"ttft_p95_ms":1888.0385460404805,"ttft_p99_ms":2540.7107848790474,"tpot_p50_ms":33.888618350413985,"tpot_p95_ms":111.5268040385751,"tpot_p99_ms":128.25639955367384,"e2e_p50_ms":5073.367008502828,"e2e_p95_ms":15214.232425496448,"e2e_p99_ms":17087.19354148547,"itl_p50_ms":20.828259497648105,"itl_p95_ms":153.31149489502386,"itl_p99_ms":515.2417080744635,"validation_errors":[],"timestamp":"2026-07-17T08:17:51+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":128,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":18.085303,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c64_i4096_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c64_i4096_o128_a1.log"} +{"status":"COMPLETED","completed":400,"failed":0,"duration_s":40.55640723198303,"request_tps":9.862806577318258,"input_tps":40398.055740695585,"output_tps":1262.439241896737,"total_tps":41660.494982592325,"mean_input_tokens":4096.0,"mean_output_tokens":128.0,"ttft_p50_ms":700.8121555118123,"ttft_p95_ms":1398.6977479580619,"ttft_p99_ms":1672.5167674149266,"tpot_p50_ms":41.50393656691019,"tpot_p95_ms":129.98133441026545,"tpot_p99_ms":143.44730871652325,"e2e_p50_ms":6014.782474012463,"e2e_p95_ms":17137.209681610693,"e2e_p99_ms":18664.649393335858,"itl_p50_ms":24.62657699652482,"itl_p95_ms":268.13879909313977,"itl_p99_ms":658.2014280499425,"validation_errors":[],"timestamp":"2026-07-17T08:19:17+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":128,"concurrency":80,"num_prompts":400,"warmup_requests":80,"attempt":1,"gain_pct":12.684015,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c80_i4096_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c80_i4096_o128_a1.log"} +{"status":"COMPLETED","completed":480,"failed":0,"duration_s":91.04096454899991,"request_tps":5.272351873443248,"input_tps":21595.553273623544,"output_tps":674.8610398007357,"total_tps":22270.41431342428,"mean_input_tokens":4096.0,"mean_output_tokens":128.0,"ttft_p50_ms":3046.3026449870085,"ttft_p95_ms":6811.207162098434,"ttft_p99_ms":8498.70939680113,"tpot_p50_ms":81.31157379532343,"tpot_p95_ms":297.5006025037947,"tpot_p99_ms":385.20635069033716,"e2e_p50_ms":15871.44419249671,"e2e_p95_ms":40764.30778361246,"e2e_p99_ms":54679.08822501864,"itl_p50_ms":25.502658012555912,"itl_p95_ms":370.33002589741955,"itl_p99_ms":2568.5368170501897,"validation_errors":[],"timestamp":"2026-07-17T08:21:35+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":128,"concurrency":96,"num_prompts":480,"warmup_requests":96,"attempt":1,"gain_pct":-46.543088,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c96_i4096_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c96_i4096_o128_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":31.34968347699032,"request_tps":2.5518598954505385,"input_tps":10452.418131765406,"output_tps":653.2761332353379,"total_tps":11105.694265000744,"mean_input_tokens":4096.0,"mean_output_tokens":256.0,"ttft_p50_ms":1689.1661849949742,"ttft_p95_ms":2771.0634881907017,"ttft_p99_ms":3094.925094784703,"tpot_p50_ms":17.29639439413315,"tpot_p95_ms":21.599934097452493,"tpot_p99_ms":23.66513310455003,"e2e_p50_ms":6170.226971007651,"e2e_p95_ms":7172.891501788399,"e2e_p99_ms":7868.678639824792,"itl_p50_ms":12.196922994917259,"itl_p95_ms":14.655565565044524,"itl_p99_ms":131.27250419463948,"validation_errors":[],"timestamp":"2026-07-17T08:22:50+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":256,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c16_i4096_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c16_i4096_o256_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":36.93074521899689,"request_tps":4.332433560471378,"input_tps":17745.647863690763,"output_tps":1109.1029914806727,"total_tps":18854.750855171435,"mean_input_tokens":4096.0,"mean_output_tokens":256.0,"ttft_p50_ms":1354.3204835004872,"ttft_p95_ms":3038.9372731980975,"ttft_p99_ms":3135.861400717986,"tpot_p50_ms":18.247490196075635,"tpot_p95_ms":35.75252716160749,"tpot_p99_ms":38.07798783515588,"e2e_p50_ms":6936.265810509212,"e2e_p95_ms":10290.905706783813,"e2e_p99_ms":12162.700288116755,"itl_p50_ms":15.369293003459461,"itl_p95_ms":16.586679051397365,"itl_p99_ms":96.57292846124665,"validation_errors":[],"timestamp":"2026-07-17T08:24:09+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":256,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":69.775526,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c32_i4096_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c32_i4096_o256_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":43.74804508101079,"request_tps":5.4859594195712775,"input_tps":22470.489782563953,"output_tps":1404.405611410247,"total_tps":23874.8953939742,"mean_input_tokens":4096.0,"mean_output_tokens":256.0,"ttft_p50_ms":830.1005314860959,"ttft_p95_ms":2180.3646098429454,"ttft_p99_ms":2769.363557187315,"tpot_p50_ms":23.487649321517285,"tpot_p95_ms":51.88085191260552,"tpot_p99_ms":57.29689655709419,"e2e_p50_ms":6940.7142140116775,"e2e_p95_ms":14197.78596296673,"e2e_p99_ms":15331.694836025417,"itl_p50_ms":18.29162100329995,"itl_p95_ms":20.576635452744085,"itl_p99_ms":366.72396419424337,"validation_errors":[],"timestamp":"2026-07-17T08:25:35+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":256,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":26.625356,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c48_i4096_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c48_i4096_o256_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":49.03539300401462,"request_tps":6.525898547887665,"input_tps":26730.080452147875,"output_tps":1670.6300282592422,"total_tps":28400.71048040712,"mean_input_tokens":4096.0,"mean_output_tokens":256.0,"ttft_p50_ms":732.7635329857003,"ttft_p95_ms":2298.4709407639457,"ttft_p99_ms":2735.201299338951,"tpot_p50_ms":26.99360208826678,"tpot_p95_ms":62.392156732795925,"tpot_p99_ms":66.36687537296288,"e2e_p50_ms":7576.005746494047,"e2e_p95_ms":17242.34077935107,"e2e_p99_ms":19311.81628182094,"itl_p50_ms":20.751672505866736,"itl_p95_ms":24.27512014983222,"itl_p99_ms":426.02455151354593,"validation_errors":[],"timestamp":"2026-07-17T08:27:08+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":256,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":18.956377,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c64_i4096_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c64_i4096_o256_a1.log"} +{"status":"COMPLETED","completed":400,"failed":0,"duration_s":54.85140435199719,"request_tps":7.292429514349083,"input_tps":29869.791290773843,"output_tps":1866.8619556733652,"total_tps":31736.653246447207,"mean_input_tokens":4096.0,"mean_output_tokens":256.0,"ttft_p50_ms":998.9687135093845,"ttft_p95_ms":2590.219415022874,"ttft_p99_ms":2976.114052276529,"tpot_p50_ms":29.978303182367966,"tpot_p95_ms":71.93918849468258,"tpot_p99_ms":82.27459098658792,"e2e_p50_ms":8624.992505996488,"e2e_p95_ms":19365.395152909292,"e2e_p99_ms":21696.167638337647,"itl_p50_ms":24.57320998655632,"itl_p95_ms":28.611041803378612,"itl_p99_ms":415.8668831584503,"validation_errors":[],"timestamp":"2026-07-17T08:28:44+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":256,"concurrency":80,"num_prompts":400,"warmup_requests":80,"attempt":1,"gain_pct":11.745983,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c80_i4096_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c80_i4096_o256_a1.log"} +{"status":"COMPLETED","completed":480,"failed":0,"duration_s":123.23578282500966,"request_tps":3.894972620749142,"input_tps":15953.807854588485,"output_tps":997.1129909117803,"total_tps":16950.920845500266,"mean_input_tokens":4096.0,"mean_output_tokens":256.0,"ttft_p50_ms":1842.4318339966703,"ttft_p95_ms":14489.050907116323,"ttft_p99_ms":17031.75237096467,"tpot_p50_ms":84.90963259805451,"tpot_p95_ms":111.01483011915,"tpot_p99_ms":127.88261852458727,"e2e_p50_ms":24656.085490511032,"e2e_p95_ms":34604.584457650955,"e2e_p99_ms":37071.07317504036,"itl_p50_ms":24.966776996734552,"itl_p95_ms":370.8094593617716,"itl_p99_ms":1287.8223710201564,"validation_errors":[],"timestamp":"2026-07-17T08:31:34+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":256,"concurrency":96,"num_prompts":480,"warmup_requests":96,"attempt":1,"gain_pct":-46.58882,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c96_i4096_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c96_i4096_o256_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":47.36712284499663,"request_tps":1.6889351768692105,"input_tps":6917.878484456286,"output_tps":864.7348105570358,"total_tps":7782.6132950133215,"mean_input_tokens":4096.0,"mean_output_tokens":512.0,"ttft_p50_ms":1629.9991665000562,"ttft_p95_ms":2764.6181574076754,"ttft_p99_ms":3087.4343710465473,"tpot_p50_ms":14.792481867874217,"tpot_p95_ms":18.097017575825955,"tpot_p99_ms":18.869392973208065,"e2e_p50_ms":9352.132365995203,"e2e_p95_ms":10624.868485546904,"e2e_p99_ms":10937.36010070017,"itl_p50_ms":12.19786649744492,"itl_p95_ms":12.896720845310481,"itl_p99_ms":32.26077246305054,"validation_errors":[],"timestamp":"2026-07-17T08:33:08+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":512,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c16_i4096_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c16_i4096_o512_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":58.284679299016716,"request_tps":2.745146785129506,"input_tps":11244.121231890456,"output_tps":1405.515153986307,"total_tps":12649.636385876764,"mean_input_tokens":4096.0,"mean_output_tokens":512.0,"ttft_p50_ms":802.875862995279,"ttft_p95_ms":1646.1451582508744,"ttft_p99_ms":1754.5462182036129,"tpot_p50_ms":20.295847814074268,"tpot_p95_ms":28.483734650588854,"tpot_p99_ms":30.90779456900081,"e2e_p50_ms":11419.980956998188,"e2e_p95_ms":15821.643079399655,"e2e_p99_ms":16989.2162742035,"itl_p50_ms":15.381649500341155,"itl_p95_ms":16.745317401364446,"itl_p99_ms":275.99993371288787,"validation_errors":[],"timestamp":"2026-07-17T08:34:48+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":512,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":62.537131,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c32_i4096_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c32_i4096_o512_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":67.73334838001756,"request_tps":3.5433062994831053,"input_tps":14513.3826026828,"output_tps":1814.17282533535,"total_tps":16327.55542801815,"mean_input_tokens":4096.0,"mean_output_tokens":512.0,"ttft_p50_ms":840.9117164992495,"ttft_p95_ms":1612.8318513394333,"ttft_p99_ms":1940.4553903482154,"tpot_p50_ms":20.516633954051326,"tpot_p95_ms":35.45086373426209,"tpot_p99_ms":38.77477101024517,"e2e_p50_ms":11478.048530989327,"e2e_p95_ms":19306.33458683441,"e2e_p99_ms":20416.257833176933,"itl_p50_ms":18.281058000866324,"itl_p95_ms":20.390048107947223,"itl_p99_ms":192.87612552550877,"validation_errors":[],"timestamp":"2026-07-17T08:36:38+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":512,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":29.075295,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c48_i4096_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c48_i4096_o512_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":73.41448802500963,"request_tps":4.358812662304309,"input_tps":17853.69666479845,"output_tps":2231.712083099806,"total_tps":20085.408747898255,"mean_input_tokens":4096.0,"mean_output_tokens":512.0,"ttft_p50_ms":884.725925483508,"ttft_p95_ms":2992.340761549713,"ttft_p99_ms":3507.7373022196116,"tpot_p50_ms":22.22099958316636,"tpot_p95_ms":41.83536868366956,"tpot_p99_ms":43.89374081192104,"e2e_p50_ms":12111.822684004437,"e2e_p95_ms":22226.395284205504,"e2e_p99_ms":25071.686333191177,"itl_p50_ms":20.780677485163324,"itl_p95_ms":22.571668511955064,"itl_p99_ms":83.26282915513669,"validation_errors":[],"timestamp":"2026-07-17T08:38:36+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":512,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":23.015407,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c64_i4096_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c64_i4096_o512_a1.log"} +{"status":"COMPLETED","completed":400,"failed":0,"duration_s":87.65993230399908,"request_tps":4.563088169094466,"input_tps":18690.409140610933,"output_tps":2336.3011425763666,"total_tps":21026.710283187298,"mean_input_tokens":4096.0,"mean_output_tokens":512.0,"ttft_p50_ms":809.4951464881888,"ttft_p95_ms":1524.1684498323582,"ttft_p99_ms":2690.3307195089287,"tpot_p50_ms":27.932202172205454,"tpot_p95_ms":49.79624132051484,"tpot_p99_ms":52.51258567199595,"e2e_p50_ms":15056.680959503865,"e2e_p95_ms":26501.45390776306,"e2e_p99_ms":27873.799721483374,"itl_p50_ms":24.556756485253572,"itl_p95_ms":28.258642400032837,"itl_p99_ms":310.3814363272977,"validation_errors":[],"timestamp":"2026-07-17T08:40:44+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":512,"concurrency":80,"num_prompts":400,"warmup_requests":80,"attempt":1,"gain_pct":4.686494,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c80_i4096_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c80_i4096_o512_a1.log"} +{"status":"COMPLETED","completed":480,"failed":0,"duration_s":155.13626290298998,"request_tps":3.0940541625664544,"input_tps":12673.245849872197,"output_tps":1584.1557312340246,"total_tps":14257.401581106222,"mean_input_tokens":4096.0,"mean_output_tokens":512.0,"ttft_p50_ms":1899.678836503881,"ttft_p95_ms":14484.92257904145,"ttft_p99_ms":17027.401388176942,"tpot_p50_ms":54.83721081702719,"tpot_p95_ms":67.01950486372654,"tpot_p99_ms":76.26754912622378,"e2e_p50_ms":31182.972469483502,"e2e_p95_ms":40844.42995285778,"e2e_p99_ms":43435.33403207519,"itl_p50_ms":24.87761850352399,"itl_p95_ms":32.057279541913864,"itl_p99_ms":463.4596330678326,"validation_errors":[],"timestamp":"2026-07-17T08:43:59+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":512,"concurrency":96,"num_prompts":480,"warmup_requests":96,"attempt":1,"gain_pct":-32.193855,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c96_i4096_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c96_i4096_o512_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":79.54505488200812,"request_tps":1.0057193387906604,"input_tps":4119.426411686545,"output_tps":1029.8566029216363,"total_tps":5149.2830146081815,"mean_input_tokens":4096.0,"mean_output_tokens":1024.0,"ttft_p50_ms":1194.9436754948692,"ttft_p95_ms":2746.423320240864,"ttft_p99_ms":3077.440734624979,"tpot_p50_ms":13.814211206261218,"tpot_p95_ms":15.376222600725928,"tpot_p99_ms":15.828327223571959,"e2e_p50_ms":15630.754935002187,"e2e_p95_ms":17355.2350877595,"e2e_p99_ms":17858.46843063977,"itl_p50_ms":12.189081986434758,"itl_p95_ms":12.663125513063278,"itl_p99_ms":15.409120005788283,"validation_errors":[],"timestamp":"2026-07-17T08:46:01+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":1024,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c16_i4096_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c16_i4096_o1024_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":98.79566569899907,"request_tps":1.61950424513027,"input_tps":6633.489388053586,"output_tps":1658.3723470133964,"total_tps":8291.861735066983,"mean_input_tokens":4096.0,"mean_output_tokens":1024.0,"ttft_p50_ms":795.5072534969077,"ttft_p95_ms":1260.939176141983,"ttft_p99_ms":1497.014678712585,"tpot_p50_ms":18.5347444809333,"tpot_p95_ms":21.662010593683295,"tpot_p99_ms":22.156984791187394,"e2e_p50_ms":19668.23125598603,"e2e_p95_ms":23170.169547996193,"e2e_p99_ms":23668.43164754333,"itl_p50_ms":15.370506007457152,"itl_p95_ms":16.752887002076022,"itl_p99_ms":41.785450707537414,"validation_errors":[],"timestamp":"2026-07-17T08:48:18+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":1024,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":61.029443,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c32_i4096_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c32_i4096_o1024_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":115.95119000700652,"request_tps":2.069836454334774,"input_tps":8478.050116955234,"output_tps":2119.5125292388084,"total_tps":10597.562646194041,"mean_input_tokens":4096.0,"mean_output_tokens":1024.0,"ttft_p50_ms":735.8261769986711,"ttft_p95_ms":1273.5483405544073,"ttft_p99_ms":1523.2312142389121,"tpot_p50_ms":20.008392668622093,"tpot_p95_ms":26.832531413871596,"tpot_p99_ms":28.705450073714147,"e2e_p50_ms":21243.57200450322,"e2e_p95_ms":28575.792114142678,"e2e_p99_ms":30033.088181467898,"itl_p50_ms":18.232964488561265,"itl_p95_ms":20.93131234432803,"itl_p99_ms":73.0781039712019,"validation_errors":[],"timestamp":"2026-07-17T08:50:58+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":1024,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":27.806794,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c48_i4096_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c48_i4096_o1024_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":129.01026274700416,"request_tps":2.4804228220784004,"input_tps":10159.811879233128,"output_tps":2539.952969808282,"total_tps":12699.76484904141,"mean_input_tokens":4096.0,"mean_output_tokens":1024.0,"ttft_p50_ms":655.6448324990924,"ttft_p95_ms":1298.3910392344117,"ttft_p99_ms":1675.1640068530105,"tpot_p50_ms":22.245849524919954,"tpot_p95_ms":32.17836112408277,"tpot_p99_ms":34.82908474925726,"e2e_p50_ms":23488.13521050033,"e2e_p95_ms":33527.339251754165,"e2e_p99_ms":35959.448536693235,"itl_p50_ms":20.764176995726302,"itl_p95_ms":23.88001790095586,"itl_p99_ms":100.57152002176642,"validation_errors":[],"timestamp":"2026-07-17T08:53:52+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":1024,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":19.836657,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c64_i4096_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c64_i4096_o1024_a1.log"} +{"status":"COMPLETED","completed":400,"failed":0,"duration_s":148.42720824701246,"request_tps":2.694923691715068,"input_tps":11038.407441264919,"output_tps":2759.6018603162297,"total_tps":13798.009301581149,"mean_input_tokens":4096.0,"mean_output_tokens":1024.0,"ttft_p50_ms":878.3656564919511,"ttft_p95_ms":1980.5035995363112,"ttft_p99_ms":2695.744535620615,"tpot_p50_ms":25.775487002923917,"tpot_p95_ms":37.05249856574823,"tpot_p99_ms":38.68893067224792,"e2e_p50_ms":27017.756770495907,"e2e_p95_ms":39071.83772518619,"e2e_p99_ms":40239.9309509006,"itl_p50_ms":24.603112004115246,"itl_p95_ms":27.757155906874686,"itl_p99_ms":38.706756650644884,"validation_errors":[],"timestamp":"2026-07-17T08:57:00+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":1024,"concurrency":80,"num_prompts":400,"warmup_requests":80,"attempt":1,"gain_pct":8.647754,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c80_i4096_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c80_i4096_o1024_a1.log"} +{"status":"COMPLETED","completed":480,"failed":0,"duration_s":219.11545323499013,"request_tps":2.1906259595722104,"input_tps":8972.803930407774,"output_tps":2243.2009826019435,"total_tps":11216.004913009716,"mean_input_tokens":4096.0,"mean_output_tokens":1024.0,"ttft_p50_ms":1720.0304760044673,"ttft_p95_ms":14488.165891336394,"ttft_p99_ms":17031.9616908516,"tpot_p50_ms":39.69507290078041,"tpot_p95_ms":46.33477780679358,"tpot_p99_ms":49.58792684254207,"e2e_p50_ms":43579.88965501136,"e2e_p95_ms":51892.75902521164,"e2e_p99_ms":56324.65708870441,"itl_p50_ms":24.791998497676104,"itl_p95_ms":29.81382450816454,"itl_p99_ms":406.9158370303882,"validation_errors":[],"timestamp":"2026-07-17T09:01:24+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":1024,"concurrency":96,"num_prompts":480,"warmup_requests":96,"attempt":1,"gain_pct":-18.712876,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c96_i4096_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c96_i4096_o1024_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":141.97658437601058,"request_tps":0.5634731977220139,"input_tps":2307.986217869369,"output_tps":1153.9931089346844,"total_tps":3461.9793268040535,"mean_input_tokens":4096.0,"mean_output_tokens":2048.0,"ttft_p50_ms":884.0503485116642,"ttft_p95_ms":2756.229292089119,"ttft_p99_ms":3080.185913645837,"tpot_p50_ms":13.136122119934313,"tpot_p95_ms":13.774269037134365,"tpot_p99_ms":14.08692297271049,"e2e_p50_ms":28092.87907498947,"e2e_p95_ms":29290.224238604424,"e2e_p99_ms":30362.109228294576,"itl_p50_ms":12.176512987934984,"itl_p95_ms":12.869427337136583,"itl_p99_ms":14.911210674617907,"validation_errors":[],"timestamp":"2026-07-17T09:04:31+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":2048,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c16_i4096_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c16_i4096_o2048_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":176.7701919809915,"request_tps":0.9051299781198696,"input_tps":3707.412390378986,"output_tps":1853.706195189493,"total_tps":5561.118585568479,"mean_input_tokens":4096.0,"mean_output_tokens":2048.0,"ttft_p50_ms":781.4161439891905,"ttft_p95_ms":1759.2999582033372,"ttft_p99_ms":1808.458056374511,"tpot_p50_ms":16.620845870051678,"tpot_p95_ms":18.686440377769877,"tpot_p99_ms":19.347013081397208,"e2e_p50_ms":34771.043315005954,"e2e_p95_ms":39782.25837273494,"e2e_p99_ms":40314.07431809086,"itl_p50_ms":15.346531014074571,"itl_p95_ms":16.93274338322226,"itl_p99_ms":19.62061838508816,"validation_errors":[],"timestamp":"2026-07-17T09:08:12+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":2048,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":60.634078,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c32_i4096_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c32_i4096_o2048_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":207.89503042100114,"request_tps":1.1544287495183707,"input_tps":4728.540158027246,"output_tps":2364.270079013623,"total_tps":7092.810237040871,"mean_input_tokens":4096.0,"mean_output_tokens":2048.0,"ttft_p50_ms":746.3213810115121,"ttft_p95_ms":2485.2938235591864,"ttft_p99_ms":2880.3725607472,"tpot_p50_ms":18.908278210550176,"tpot_p95_ms":22.803009965474764,"tpot_p99_ms":23.77992212627291,"e2e_p50_ms":39462.443572992925,"e2e_p95_ms":48030.13592433563,"e2e_p99_ms":49747.67224883543,"itl_p50_ms":18.19151699601207,"itl_p95_ms":20.86531965760514,"itl_p99_ms":24.989815584267507,"validation_errors":[],"timestamp":"2026-07-17T09:12:24+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":2048,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":27.54287,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c48_i4096_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c48_i4096_o2048_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":237.73899826299748,"request_tps":1.3460139158406048,"input_tps":5513.272999283117,"output_tps":2756.6364996415587,"total_tps":8269.909498924677,"mean_input_tokens":4096.0,"mean_output_tokens":2048.0,"ttft_p50_ms":524.3038179905852,"ttft_p95_ms":1120.484024954203,"ttft_p99_ms":1180.9750111078029,"tpot_p50_ms":22.039404359298544,"tpot_p95_ms":26.647347694502116,"tpot_p99_ms":27.2550087284635,"e2e_p50_ms":45795.051639011945,"e2e_p95_ms":55374.89530928724,"e2e_p99_ms":56364.74995819561,"itl_p50_ms":20.715202495921403,"itl_p95_ms":24.651048867963247,"itl_p99_ms":53.086119215586045,"validation_errors":[],"timestamp":"2026-07-17T09:17:03+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":2048,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":16.595668,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c64_i4096_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c64_i4096_o2048_a1.log"} +{"status":"COMPLETED","completed":400,"failed":0,"duration_s":277.70246060501086,"request_tps":1.4403905501180942,"input_tps":5899.839693283714,"output_tps":2949.919846641857,"total_tps":8849.759539925572,"mean_input_tokens":4096.0,"mean_output_tokens":2048.0,"ttft_p50_ms":550.5605719808955,"ttft_p95_ms":1283.5930572808136,"ttft_p99_ms":1451.407603152911,"tpot_p50_ms":25.718601174646263,"tpot_p95_ms":31.28441111485291,"tpot_p99_ms":32.327067536224796,"e2e_p50_ms":53450.52659850626,"e2e_p95_ms":64567.21738499763,"e2e_p99_ms":66766.48194762586,"itl_p50_ms":24.50430100725498,"itl_p95_ms":28.522449343290646,"itl_p99_ms":66.24933546467227,"validation_errors":[],"timestamp":"2026-07-17T09:22:26+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":2048,"concurrency":80,"num_prompts":400,"warmup_requests":80,"attempt":1,"gain_pct":7.011565,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c80_i4096_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c80_i4096_o2048_a1.log"} +{"status":"COMPLETED","completed":480,"failed":0,"duration_s":348.1090026909951,"request_tps":1.3788784440777022,"input_tps":5647.886106942268,"output_tps":2823.943053471134,"total_tps":8471.829160413403,"mean_input_tokens":4096.0,"mean_output_tokens":2048.0,"ttft_p50_ms":1668.0721489829011,"ttft_p95_ms":14481.274036238026,"ttft_p99_ms":17022.639714278626,"tpot_p50_ms":32.24183149707108,"tpot_p95_ms":36.07043753760679,"tpot_p99_ms":37.71377028430149,"e2e_p50_ms":69486.28412648395,"e2e_p95_ms":77366.32149510672,"e2e_p99_ms":82790.03862885758,"itl_p50_ms":24.725820010644384,"itl_p95_ms":30.024395903456025,"itl_p99_ms":317.8822695944154,"validation_errors":[],"timestamp":"2026-07-17T09:29:00+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":2048,"concurrency":96,"num_prompts":480,"warmup_requests":96,"attempt":1,"gain_pct":-4.270516,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c96_i4096_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c96_i4096_o2048_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":266.24431526998524,"request_tps":0.300475899058637,"input_tps":1230.749282544177,"output_tps":1230.749282544177,"total_tps":2461.498565088354,"mean_input_tokens":4096.0,"mean_output_tokens":4096.0,"ttft_p50_ms":840.9119694842957,"ttft_p95_ms":2754.2899743493754,"ttft_p99_ms":3081.1643113032915,"tpot_p50_ms":12.692203347372761,"tpot_p95_ms":13.09188080972751,"tpot_p99_ms":13.201501907743097,"e2e_p50_ms":52871.73911399441,"e2e_p95_ms":55248.81887739757,"e2e_p99_ms":55513.79410967609,"itl_p50_ms":12.16021299478598,"itl_p95_ms":12.945477038738316,"itl_p99_ms":15.074126886320302,"validation_errors":[],"timestamp":"2026-07-17T09:34:06+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":4096,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c16_i4096_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c16_i4096_o4096_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":335.26076182498946,"request_tps":0.4772404594234088,"input_tps":1954.7769217982825,"output_tps":1954.7769217982825,"total_tps":3909.553843596565,"mean_input_tokens":4096.0,"mean_output_tokens":4096.0,"ttft_p50_ms":820.0882940000156,"ttft_p95_ms":1027.5020232817017,"ttft_p99_ms":1207.5220876370438,"tpot_p50_ms":16.01485316666859,"tpot_p95_ms":17.097932153784882,"tpot_p99_ms":17.249814591048,"e2e_p50_ms":66233.35381450306,"e2e_p95_ms":70666.2702016969,"e2e_p99_ms":71448.1904130237,"itl_p50_ms":15.303591993870214,"itl_p95_ms":17.704268686065916,"itl_p99_ms":30.341602329572197,"validation_errors":[],"timestamp":"2026-07-17T09:40:19+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":4096,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":58.828199,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c32_i4096_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c32_i4096_o4096_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":396.60371269701864,"request_tps":0.6051380567466991,"input_tps":2478.6454804344794,"output_tps":2478.6454804344794,"total_tps":4957.290960868959,"mean_input_tokens":4096.0,"mean_output_tokens":4096.0,"ttft_p50_ms":868.5066229954828,"ttft_p95_ms":5572.87702600006,"ttft_p99_ms":5968.62416484335,"tpot_p50_ms":18.64478194529844,"tpot_p95_ms":20.068367691356652,"tpot_p99_ms":21.203687685439533,"e2e_p50_ms":77594.15599850763,"e2e_p95_ms":85193.51727115423,"e2e_p99_ms":88194.92268489033,"itl_p50_ms":18.000286509050056,"itl_p95_ms":31.555646525521293,"itl_p99_ms":149.35246548935538,"validation_errors":[],"timestamp":"2026-07-17T09:47:43+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":4096,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":26.799404,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c48_i4096_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c48_i4096_o4096_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":51.02242224800284,"request_tps":1.5679381039799893,"input_tps":25689.097895608145,"output_tps":200.69607730943864,"total_tps":25889.793972917585,"mean_input_tokens":16384.0,"mean_output_tokens":128.0,"ttft_p50_ms":2998.899683007039,"ttft_p95_ms":6794.889196609438,"ttft_p99_ms":7121.470326042327,"tpot_p50_ms":45.208260381922464,"tpot_p95_ms":113.38018917171077,"tpot_p99_ms":166.2344710016117,"e2e_p50_ms":8758.094143500784,"e2e_p95_ms":17314.082136437344,"e2e_p99_ms":24471.146503761403,"itl_p50_ms":12.353217505733483,"itl_p95_ms":18.275703059043735,"itl_p99_ms":840.0441553624111,"validation_errors":[],"timestamp":"2026-07-17T09:49:19+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":16384,"osl":128,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c16_i16384_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c16_i16384_o128_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":14.62797428900376,"request_tps":2.7344866219835424,"input_tps":44801.82881457836,"output_tps":350.01428761389343,"total_tps":45151.84310219225,"mean_input_tokens":16384.0,"mean_output_tokens":128.0,"ttft_p50_ms":452.98437650490087,"ttft_p95_ms":3885.584330555865,"ttft_p99_ms":4405.600669286214,"tpot_p50_ms":10.740162409414854,"tpot_p95_ms":31.875752733848856,"tpot_p99_ms":58.632151106377975,"e2e_p50_ms":1834.2678049812093,"e2e_p95_ms":7695.436597142542,"e2e_p99_ms":7802.47788591194,"itl_p50_ms":10.225326012005098,"itl_p95_ms":12.226175122486893,"itl_p99_ms":44.986372183775536,"validation_errors":[],"timestamp":"2026-07-17T09:50:14+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":16384,"osl":128,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c8_i16384_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c8_i16384_o128_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":31.297320540004876,"request_tps":2.556129362503808,"input_tps":41879.62347526239,"output_tps":654.3691168009749,"total_tps":42533.99259206337,"mean_input_tokens":16384.0,"mean_output_tokens":256.0,"ttft_p50_ms":597.8162964893272,"ttft_p95_ms":3496.5043898846475,"ttft_p99_ms":5954.214138324603,"tpot_p50_ms":13.708327905909506,"tpot_p95_ms":38.235667277904746,"tpot_p99_ms":42.27862333468905,"e2e_p50_ms":5433.7005035049515,"e2e_p95_ms":10338.1358756058,"e2e_p99_ms":13865.649996678112,"itl_p50_ms":12.23703200230375,"itl_p95_ms":15.636277406883892,"itl_p99_ms":115.76958119840104,"validation_errors":[],"timestamp":"2026-07-17T09:51:27+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":16384,"osl":256,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c16_i16384_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c16_i16384_o256_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":88.63646369698108,"request_tps":1.8051261673410999,"input_tps":29575.18712571658,"output_tps":462.11229883932157,"total_tps":30037.299424555902,"mean_input_tokens":16384.0,"mean_output_tokens":256.0,"ttft_p50_ms":2995.0797445053468,"ttft_p95_ms":6696.018199381066,"ttft_p99_ms":8929.114069283238,"tpot_p50_ms":60.46463561172405,"tpot_p95_ms":104.25349157987793,"tpot_p99_ms":126.02659744681111,"e2e_p50_ms":18462.857925507706,"e2e_p95_ms":30535.8572390367,"e2e_p99_ms":36314.939617510245,"itl_p50_ms":15.350472502177581,"itl_p95_ms":18.77957450051326,"itl_p99_ms":832.3941676929826,"validation_errors":[],"timestamp":"2026-07-17T09:53:36+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":16384,"osl":256,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":-29.380485,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c32_i16384_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c32_i16384_o256_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":92.91524574998766,"request_tps":0.8609997138172626,"input_tps":14106.61931118203,"output_tps":440.83185347443845,"total_tps":14547.451164656468,"mean_input_tokens":16384.0,"mean_output_tokens":512.0,"ttft_p50_ms":3088.8925309991464,"ttft_p95_ms":10028.143283702955,"ttft_p99_ms":11957.341678629746,"tpot_p50_ms":28.68600893642552,"tpot_p95_ms":35.27262346320291,"tpot_p99_ms":40.55267818854361,"e2e_p50_ms":17919.484345504316,"e2e_p95_ms":24576.7945223939,"e2e_p99_ms":24803.905932064226,"itl_p50_ms":12.19817899982445,"itl_p95_ms":14.822904994070996,"itl_p99_ms":122.84888085938275,"validation_errors":[],"timestamp":"2026-07-17T09:55:56+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":16384,"osl":512,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c16_i16384_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c16_i16384_o512_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":32.07205949301715,"request_tps":1.2471915003995597,"input_tps":20433.985542546387,"output_tps":638.5620482045746,"total_tps":21072.54759075096,"mean_input_tokens":16384.0,"mean_output_tokens":512.0,"ttft_p50_ms":294.77026949462015,"ttft_p95_ms":3124.4490633645905,"ttft_p99_ms":3237.4198830264504,"tpot_p50_ms":10.5285436496956,"tpot_p95_ms":14.277684379731479,"tpot_p99_ms":16.371963940862223,"e2e_p50_ms":5690.379223990021,"e2e_p95_ms":8605.527856625848,"e2e_p99_ms":9381.375242091015,"itl_p50_ms":10.21807300276123,"itl_p95_ms":10.86074557242682,"itl_p99_ms":12.742342634301172,"validation_errors":[],"timestamp":"2026-07-17T09:57:10+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":16384,"osl":512,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c8_i16384_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c8_i16384_o512_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":82.83058624601108,"request_tps":0.9658267993226066,"input_tps":15824.106280101587,"output_tps":989.0066425063492,"total_tps":16813.112922607936,"mean_input_tokens":16384.0,"mean_output_tokens":1024.0,"ttft_p50_ms":645.9299859998282,"ttft_p95_ms":3350.738326196733,"ttft_p99_ms":4567.837153388523,"tpot_p50_ms":13.130660296678597,"tpot_p95_ms":20.98559533836729,"tpot_p99_ms":22.408576523554245,"e2e_p50_ms":14573.275214002933,"e2e_p95_ms":22674.44602535834,"e2e_p99_ms":25624.61908869067,"itl_p50_ms":12.206763494759798,"itl_p95_ms":15.182556334184483,"itl_p99_ms":16.226811511151027,"validation_errors":[],"timestamp":"2026-07-17T09:59:09+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":16384,"osl":1024,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c16_i16384_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c16_i16384_o1024_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":152.4588420089858,"request_tps":1.049463565980448,"input_tps":17194.41106502366,"output_tps":1074.6506915639789,"total_tps":18269.061756587642,"mean_input_tokens":16384.0,"mean_output_tokens":1024.0,"ttft_p50_ms":2978.1398644990986,"ttft_p95_ms":5759.133025548362,"ttft_p99_ms":7284.352425320534,"tpot_p50_ms":27.452394525410803,"tpot_p95_ms":39.86601451364787,"tpot_p99_ms":48.30455956359732,"e2e_p50_ms":30410.698643012438,"e2e_p95_ms":44048.84817325651,"e2e_p99_ms":55050.551999781455,"itl_p50_ms":15.384290003567003,"itl_p95_ms":18.547037002281286,"itl_p99_ms":88.0078978720119,"validation_errors":[],"timestamp":"2026-07-17T10:02:22+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":16384,"osl":1024,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":8.659603,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c32_i16384_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c32_i16384_o1024_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":184.0782314479875,"request_tps":0.4345978303393496,"input_tps":7120.450852279904,"output_tps":890.056356534988,"total_tps":8010.507208814893,"mean_input_tokens":16384.0,"mean_output_tokens":2048.0,"ttft_p50_ms":3959.5797604997642,"ttft_p95_ms":9840.370677523602,"ttft_p99_ms":11862.585171010578,"tpot_p50_ms":15.04802362701383,"tpot_p95_ms":17.636396450410395,"tpot_p99_ms":18.09513089552332,"e2e_p50_ms":36509.76756650198,"e2e_p95_ms":40440.231163478165,"e2e_p99_ms":42314.030864318775,"itl_p50_ms":12.160479513113387,"itl_p95_ms":12.995865031552963,"itl_p99_ms":15.12032066268148,"validation_errors":[],"timestamp":"2026-07-17T10:06:14+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":16384,"osl":2048,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c16_i16384_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c16_i16384_o2048_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":118.87306600098964,"request_tps":0.3364933819378983,"input_tps":5513.107569670526,"output_tps":689.1384462088157,"total_tps":6202.246015879342,"mean_input_tokens":16384.0,"mean_output_tokens":2048.0,"ttft_p50_ms":511.18926699564327,"ttft_p95_ms":3132.4091628019232,"ttft_p99_ms":3239.2901739027,"tpot_p50_ms":10.27692181265694,"tpot_p95_ms":11.915251688882746,"tpot_p99_ms":12.028952042572513,"e2e_p50_ms":23550.685417983914,"e2e_p95_ms":24888.08726410789,"e2e_p99_ms":26645.284118684936,"itl_p50_ms":10.214920999715105,"itl_p95_ms":10.37029164872365,"itl_p99_ms":12.44674803601811,"validation_errors":[],"timestamp":"2026-07-17T10:08:56+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":16384,"osl":2048,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c8_i16384_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c8_i16384_o2048_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":248.2346583920007,"request_tps":0.32227570685825707,"input_tps":21120.660724662735,"output_tps":41.251290477856905,"total_tps":21161.91201514059,"mean_input_tokens":65536.0,"mean_output_tokens":128.0,"ttft_p50_ms":13598.038017502404,"ttft_p95_ms":33039.07567785209,"ttft_p99_ms":46230.24028092971,"tpot_p50_ms":222.79659009838338,"tpot_p95_ms":494.93139342781416,"tpot_p99_ms":661.1067587228447,"e2e_p50_ms":50941.012123497785,"e2e_p95_ms":77738.61068702527,"e2e_p99_ms":103903.11233219923,"itl_p50_ms":12.484176506404765,"itl_p95_ms":18.263139550981577,"itl_p99_ms":11371.108116148098,"validation_errors":[],"timestamp":"2026-07-17T10:13:59+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":65536,"osl":128,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c16_i65536_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c16_i65536_o128_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":135.5090699219727,"request_tps":0.295183193442567,"input_tps":19345.12576545207,"output_tps":37.783448760648575,"total_tps":19382.90921421272,"mean_input_tokens":65536.0,"mean_output_tokens":128.0,"ttft_p50_ms":12666.323071491206,"ttft_p95_ms":24935.21857734886,"ttft_p99_ms":26622.825048374358,"tpot_p50_ms":101.10752147647156,"tpot_p95_ms":302.25745743615175,"tpot_p99_ms":368.0353933333842,"e2e_p50_ms":26104.804119997425,"e2e_p95_ms":51872.7985622943,"e2e_p99_ms":65645.75840704783,"itl_p50_ms":10.203686004388146,"itl_p95_ms":12.564552307594568,"itl_p99_ms":812.3162125531235,"validation_errors":[],"timestamp":"2026-07-17T10:17:12+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":65536,"osl":128,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c8_i65536_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c8_i65536_o128_a1.log"} +{"status":"COMPLETED","completed":5,"failed":0,"duration_s":68.80302081801347,"request_tps":0.07267122781171462,"input_tps":4762.581585868529,"output_tps":9.301917159899471,"total_tps":4771.883503028429,"mean_input_tokens":65536.0,"mean_output_tokens":128.0,"ttft_p50_ms":12588.365655014059,"ttft_p95_ms":12806.853898387635,"ttft_p99_ms":12816.890314860502,"tpot_p50_ms":9.030199637654876,"tpot_p95_ms":9.099077584320957,"tpot_p99_ms":9.1116966759808,"e2e_p50_ms":13734.002451994456,"e2e_p95_ms":13962.289876391878,"e2e_p99_ms":13974.04641766916,"itl_p50_ms":9.041438024723902,"itl_p95_ms":9.145049392827787,"itl_p99_ms":9.181380511145106,"validation_errors":[],"timestamp":"2026-07-17T10:19:15+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":65536,"osl":128,"concurrency":1,"num_prompts":5,"warmup_requests":1,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/raw_outputs/sglang_adaptive_c1_i65536_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp2_dp4/logs/sglang_c1_i65536_o128_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":15.25147928801016,"request_tps":5.2453928231664335,"input_tps":5371.282250922428,"output_tps":671.4102813653035,"total_tps":6042.692532287731,"mean_input_tokens":1024.0,"mean_output_tokens":128.0,"ttft_p50_ms":622.0581405068515,"ttft_p95_ms":1513.4959525079466,"ttft_p99_ms":1520.2998693546397,"tpot_p50_ms":18.323608551162486,"tpot_p95_ms":21.88451932374237,"tpot_p99_ms":24.57394920833091,"e2e_p50_ms":2859.104725997895,"e2e_p95_ms":3961.182848791941,"e2e_p99_ms":3966.032959902077,"itl_p50_ms":11.308172513963655,"itl_p95_ms":13.305243900686033,"itl_p99_ms":211.44913432770406,"validation_errors":[],"timestamp":"2026-07-17T10:37:20+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":128,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c16_i1024_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c16_i1024_o128_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":16.05269673402654,"request_tps":9.967172659585078,"input_tps":10206.38480341512,"output_tps":1275.79810042689,"total_tps":11482.18290384201,"mean_input_tokens":1024.0,"mean_output_tokens":128.0,"ttft_p50_ms":1343.1653605075553,"ttft_p95_ms":1881.9878951049743,"ttft_p99_ms":1980.92263049155,"tpot_p50_ms":15.347931385897358,"tpot_p95_ms":17.167610000804295,"tpot_p99_ms":23.372239732361347,"e2e_p50_ms":3300.3341004950926,"e2e_p95_ms":3796.5732209166163,"e2e_p99_ms":3812.1285685908515,"itl_p50_ms":14.401425985852256,"itl_p95_ms":15.008226450299844,"itl_p99_ms":22.81718789134175,"validation_errors":[],"timestamp":"2026-07-17T10:38:14+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":128,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":90.017659,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c32_i1024_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c32_i1024_o128_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":18.75063239800511,"request_tps":12.79956829752226,"input_tps":13106.757936662794,"output_tps":1638.3447420828493,"total_tps":14745.102678745645,"mean_input_tokens":1024.0,"mean_output_tokens":128.0,"ttft_p50_ms":1003.7248610024108,"ttft_p95_ms":2434.0095029125223,"ttft_p99_ms":2486.9898583480967,"tpot_p50_ms":17.733463807023263,"tpot_p95_ms":25.59744958825617,"tpot_p99_ms":31.74014936061255,"e2e_p50_ms":3268.532721995143,"e2e_p95_ms":4846.930287292343,"e2e_p99_ms":4905.884545135195,"itl_p50_ms":16.615681000985205,"itl_p95_ms":17.413029192539398,"itl_p99_ms":27.010115072189333,"validation_errors":[],"timestamp":"2026-07-17T10:39:10+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":128,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":28.417243,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c48_i1024_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c48_i1024_o128_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":21.53067222199752,"request_tps":14.86251783969204,"input_tps":15219.21826784465,"output_tps":1902.4022834805812,"total_tps":17121.62055132523,"mean_input_tokens":1024.0,"mean_output_tokens":128.0,"ttft_p50_ms":1054.911858504056,"ttft_p95_ms":1563.3296338477521,"ttft_p99_ms":1753.48246766167,"tpot_p50_ms":20.186411913399088,"tpot_p95_ms":41.157660376787916,"tpot_p99_ms":41.38564038578756,"e2e_p50_ms":3677.209101500921,"e2e_p95_ms":6269.057958426132,"e2e_p99_ms":6607.422484531999,"itl_p50_ms":18.837003502994776,"itl_p95_ms":21.213414214435034,"itl_p99_ms":123.49141212092945,"validation_errors":[],"timestamp":"2026-07-17T10:40:13+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":128,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":16.117337,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c64_i1024_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c64_i1024_o128_a1.log"} +{"status":"COMPLETED","completed":400,"failed":0,"duration_s":22.96553739500814,"request_tps":17.41740213259478,"input_tps":17835.419783777055,"output_tps":2229.427472972132,"total_tps":20064.847256749188,"mean_input_tokens":1024.0,"mean_output_tokens":128.0,"ttft_p50_ms":1224.3392985110404,"ttft_p95_ms":4119.301676788018,"ttft_p99_ms":4450.36077607132,"tpot_p50_ms":21.775352212648077,"tpot_p95_ms":36.645399326791775,"tpot_p99_ms":43.43579882804459,"e2e_p50_ms":3952.611294997041,"e2e_p95_ms":7088.956450445402,"e2e_p99_ms":7118.542649516603,"itl_p50_ms":20.451894000871107,"itl_p95_ms":21.198717787046917,"itl_p99_ms":36.013032349583376,"validation_errors":[],"timestamp":"2026-07-17T10:41:13+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":128,"concurrency":80,"num_prompts":400,"warmup_requests":80,"attempt":1,"gain_pct":17.190118,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c80_i1024_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c80_i1024_o128_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":16.946142405999126,"request_tps":4.720838411677639,"input_tps":4834.1385335579025,"output_tps":1208.5346333894756,"total_tps":6042.673166947378,"mean_input_tokens":1024.0,"mean_output_tokens":256.0,"ttft_p50_ms":472.41895949991886,"ttft_p95_ms":534.8038905925932,"ttft_p99_ms":541.6242718329886,"tpot_p50_ms":11.350802633301903,"tpot_p95_ms":11.59216786297061,"tpot_p99_ms":11.744477820177515,"e2e_p50_ms":3374.4559774931986,"e2e_p95_ms":3467.7931153666577,"e2e_p99_ms":3474.5185076000053,"itl_p50_ms":11.296441982267424,"itl_p95_ms":11.770738651102874,"itl_p99_ms":13.540851400757623,"validation_errors":[],"timestamp":"2026-07-17T10:42:13+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":256,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c16_i1024_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c16_i1024_o256_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":24.43899106400204,"request_tps":6.546915115316508,"input_tps":6704.041078084104,"output_tps":1676.010269521026,"total_tps":8380.05134760513,"mean_input_tokens":1024.0,"mean_output_tokens":256.0,"ttft_p50_ms":532.8873034886783,"ttft_p95_ms":731.4423125731992,"ttft_p99_ms":866.4075209770817,"tpot_p50_ms":16.230282303877175,"tpot_p95_ms":20.187241967108925,"tpot_p99_ms":20.690476386431218,"e2e_p50_ms":4671.2786044954555,"e2e_p95_ms":5595.76436250354,"e2e_p99_ms":5788.156012601685,"itl_p50_ms":14.4139274925692,"itl_p95_ms":15.962127242528364,"itl_p99_ms":115.19742621225309,"validation_errors":[],"timestamp":"2026-07-17T10:43:17+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":256,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":38.681195,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c32_i1024_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c32_i1024_o256_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":27.997859761002474,"request_tps":8.572083796715422,"input_tps":8777.813807836592,"output_tps":2194.453451959148,"total_tps":10972.267259795739,"mean_input_tokens":1024.0,"mean_output_tokens":256.0,"ttft_p50_ms":766.7562955030007,"ttft_p95_ms":995.058826902823,"ttft_p99_ms":1013.1920960175922,"tpot_p50_ms":18.669868864783307,"tpot_p95_ms":22.1645906568829,"tpot_p99_ms":22.175520361069015,"e2e_p50_ms":5506.385012005921,"e2e_p95_ms":6484.546067599149,"e2e_p99_ms":6645.691189724021,"itl_p50_ms":16.6257829987444,"itl_p95_ms":18.484021458425556,"itl_p99_ms":113.8693822338247,"validation_errors":[],"timestamp":"2026-07-17T10:44:24+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":256,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":30.933175,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c48_i1024_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c48_i1024_o256_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":31.835663735982962,"request_tps":10.051620178357172,"input_tps":10292.859062637745,"output_tps":2573.214765659436,"total_tps":12866.07382829718,"mean_input_tokens":1024.0,"mean_output_tokens":256.0,"ttft_p50_ms":690.6421029998455,"ttft_p95_ms":1103.261846768146,"ttft_p99_ms":1116.6200367407873,"tpot_p50_ms":21.045824221515684,"tpot_p95_ms":26.8293056928943,"tpot_p99_ms":27.621976642503046,"e2e_p50_ms":6129.5404249976855,"e2e_p95_ms":7338.1645027868235,"e2e_p99_ms":7564.082795953436,"itl_p50_ms":18.765996501315385,"itl_p95_ms":21.64449253905332,"itl_p99_ms":111.7326270349439,"validation_errors":[],"timestamp":"2026-07-17T10:45:31+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":256,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":17.259938,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c64_i1024_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c64_i1024_o256_a1.log"} +{"status":"COMPLETED","completed":400,"failed":0,"duration_s":34.02365319701494,"request_tps":11.756527074967186,"input_tps":12038.683724766399,"output_tps":3009.6709311915997,"total_tps":15048.354655957999,"mean_input_tokens":1024.0,"mean_output_tokens":256.0,"ttft_p50_ms":837.8062309930101,"ttft_p95_ms":1339.700103842185,"ttft_p99_ms":1407.136562638625,"tpot_p50_ms":22.870419431402457,"tpot_p95_ms":26.37822345173091,"tpot_p99_ms":27.8308603639267,"e2e_p50_ms":6624.815667993971,"e2e_p95_ms":7315.728707250642,"e2e_p99_ms":8012.228765200415,"itl_p50_ms":20.392927006469108,"itl_p95_ms":21.34842018567724,"itl_p99_ms":37.944939208100486,"validation_errors":[],"timestamp":"2026-07-17T10:46:50+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":256,"concurrency":80,"num_prompts":400,"warmup_requests":80,"attempt":1,"gain_pct":16.961513,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c80_i1024_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c80_i1024_o256_a1.log"} +{"status":"COMPLETED","completed":480,"failed":0,"duration_s":40.00317194199306,"request_tps":11.999048492855218,"input_tps":12287.025656683743,"output_tps":3071.756414170936,"total_tps":15358.78207085468,"mean_input_tokens":1024.0,"mean_output_tokens":256.0,"ttft_p50_ms":1305.1264859968796,"ttft_p95_ms":2394.534821357228,"ttft_p99_ms":2733.723876553995,"tpot_p50_ms":23.914927017690122,"tpot_p95_ms":37.595357740167806,"tpot_p99_ms":37.72878658425464,"e2e_p50_ms":7283.144102504593,"e2e_p95_ms":10178.405896846367,"e2e_p99_ms":10554.591445980768,"itl_p50_ms":21.850274002645165,"itl_p95_ms":23.44233735057059,"itl_p99_ms":50.241518905095226,"validation_errors":[],"timestamp":"2026-07-17T10:48:08+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":256,"concurrency":96,"num_prompts":480,"warmup_requests":96,"attempt":1,"gain_pct":2.062866,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c96_i1024_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c96_i1024_o256_a1.log"} +{"status":"COMPLETED","completed":560,"failed":0,"duration_s":42.16918592300499,"request_tps":13.279839004302367,"input_tps":13598.555140405624,"output_tps":3399.638785101406,"total_tps":16998.193925507032,"mean_input_tokens":1024.0,"mean_output_tokens":256.0,"ttft_p50_ms":1564.9047340120887,"ttft_p95_ms":4334.344136946311,"ttft_p99_ms":4762.933305515908,"tpot_p50_ms":24.666174699999758,"tpot_p95_ms":37.29102744407012,"tpot_p99_ms":38.00148890209818,"e2e_p50_ms":7792.618515013601,"e2e_p95_ms":10879.39672227657,"e2e_p99_ms":11116.494881458348,"itl_p50_ms":23.388407003949396,"itl_p95_ms":24.829771986696866,"itl_p99_ms":33.23920242488391,"validation_errors":[],"timestamp":"2026-07-17T10:49:35+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":256,"concurrency":112,"num_prompts":560,"warmup_requests":112,"attempt":1,"gain_pct":10.674101,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c112_i1024_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c112_i1024_o256_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":34.18174446700141,"request_tps":2.3404305791716076,"input_tps":2396.600913071726,"output_tps":1198.300456535863,"total_tps":3594.9013696075895,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":466.9368670001859,"ttft_p95_ms":501.11222235136665,"ttft_p99_ms":713.0069830999126,"tpot_p50_ms":12.238893859115075,"tpot_p95_ms":13.680325238549681,"tpot_p99_ms":13.770971676177998,"e2e_p50_ms":6755.349091006792,"e2e_p95_ms":7454.24409818952,"e2e_p99_ms":7465.539258898934,"itl_p50_ms":11.2923170090653,"itl_p95_ms":11.684883208363317,"itl_p99_ms":19.464140734635162,"validation_errors":[],"timestamp":"2026-07-17T10:50:51+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":512,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c16_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c16_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":43.75388525699964,"request_tps":3.6568181102135062,"input_tps":3744.5817448586304,"output_tps":1872.2908724293152,"total_tps":5616.872617287945,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":495.62790199706797,"ttft_p95_ms":704.3985861790133,"ttft_p99_ms":742.0985969423782,"tpot_p50_ms":15.443213482360253,"tpot_p95_ms":18.988241358616193,"tpot_p99_ms":19.417835618714996,"e2e_p50_ms":8222.993365488946,"e2e_p95_ms":10220.459456891695,"e2e_p99_ms":10663.895758104045,"itl_p50_ms":14.384424517629668,"itl_p95_ms":16.208768953219987,"itl_p99_ms":40.276812358351926,"validation_errors":[],"timestamp":"2026-07-17T10:52:13+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":512,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":56.245528,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c32_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c32_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":47.59223367800587,"request_tps":5.042839586470447,"input_tps":5163.867736545738,"output_tps":2581.933868272869,"total_tps":7745.801604818606,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":843.7762595131062,"ttft_p95_ms":1014.1679494714482,"ttft_p99_ms":1029.1999262178433,"tpot_p50_ms":16.867335351272175,"tpot_p95_ms":18.077155257169807,"tpot_p99_ms":18.18941817618508,"e2e_p50_ms":9410.347732991795,"e2e_p95_ms":9936.839760841392,"e2e_p99_ms":10098.12935316615,"itl_p50_ms":16.612757986877114,"itl_p95_ms":17.343495044042356,"itl_p99_ms":20.804857902694497,"validation_errors":[],"timestamp":"2026-07-17T10:53:40+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":512,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":37.90239,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c48_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c48_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":55.31961034599226,"request_tps":5.784567136293704,"input_tps":5923.396747564753,"output_tps":2961.6983737823766,"total_tps":8885.095121347129,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":713.8400715048192,"ttft_p95_ms":1101.744504160888,"ttft_p99_ms":1118.9491916808765,"tpot_p50_ms":20.093475047960503,"tpot_p95_ms":21.867174483569034,"tpot_p99_ms":22.121782944284366,"e2e_p50_ms":10967.592675515334,"e2e_p95_ms":11735.193231310404,"e2e_p99_ms":11826.806943070551,"itl_p50_ms":18.833366018952802,"itl_p95_ms":20.23437579773599,"itl_p99_ms":33.48926824866785,"validation_errors":[],"timestamp":"2026-07-17T10:55:18+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":512,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":14.70853,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c64_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c64_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":400,"failed":0,"duration_s":59.97123937198194,"request_tps":6.669863824539812,"input_tps":6829.940556328767,"output_tps":3414.9702781643837,"total_tps":10244.910834493152,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":772.1226674912032,"ttft_p95_ms":1318.960683089972,"ttft_p99_ms":1327.420676672191,"tpot_p50_ms":21.512742028373463,"tpot_p95_ms":23.79373365216032,"tpot_p99_ms":24.044624012932516,"e2e_p50_ms":11798.972287011566,"e2e_p95_ms":12610.411101838681,"e2e_p99_ms":12994.342252617062,"itl_p50_ms":20.401706991833635,"itl_p95_ms":21.348796250822488,"itl_p99_ms":29.808988789154835,"validation_errors":[],"timestamp":"2026-07-17T10:56:56+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":512,"concurrency":80,"num_prompts":400,"warmup_requests":80,"attempt":1,"gain_pct":15.304459,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c80_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c80_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":480,"failed":0,"duration_s":67.74177824400249,"request_tps":7.0857307328287735,"input_tps":7255.788270416664,"output_tps":3627.894135208332,"total_tps":10883.682405624995,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":744.8092014965368,"ttft_p95_ms":1503.9906276710099,"ttft_p99_ms":1532.1082462440245,"tpot_p50_ms":24.64371653323366,"tpot_p95_ms":28.16295609651124,"tpot_p99_ms":28.242656123558895,"e2e_p50_ms":13412.192980991676,"e2e_p95_ms":14914.684314747865,"e2e_p99_ms":15082.95065220329,"itl_p50_ms":21.905368004809134,"itl_p95_ms":24.8308748632553,"itl_p99_ms":99.95890081219814,"validation_errors":[],"timestamp":"2026-07-17T10:58:44+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":512,"concurrency":96,"num_prompts":480,"warmup_requests":96,"attempt":1,"gain_pct":6.235013,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c96_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c96_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":560,"failed":0,"duration_s":71.7630824559892,"request_tps":7.803455214503032,"input_tps":7990.738139651105,"output_tps":3995.3690698255523,"total_tps":11986.107209476657,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":639.4832074875012,"ttft_p95_ms":1658.9624500396894,"ttft_p99_ms":1730.3955927854986,"tpot_p50_ms":26.58664183855743,"tpot_p95_ms":28.659819619371984,"tpot_p99_ms":29.05656234394778,"e2e_p50_ms":14335.342707505333,"e2e_p95_ms":15163.05780531111,"e2e_p99_ms":15409.800616905268,"itl_p50_ms":23.424350991263054,"itl_p95_ms":26.199432140856512,"itl_p99_ms":101.19458570377893,"validation_errors":[],"timestamp":"2026-07-17T11:00:42+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":512,"concurrency":112,"num_prompts":560,"warmup_requests":112,"attempt":1,"gain_pct":10.129153,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c112_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c112_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":640,"failed":0,"duration_s":76.94270334398607,"request_tps":8.317877747793263,"input_tps":8517.506813740301,"output_tps":4258.753406870151,"total_tps":12776.260220610451,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":1108.9973005000502,"ttft_p95_ms":1876.3983200333314,"ttft_p99_ms":1891.0121260368035,"tpot_p50_ms":27.333445938389726,"tpot_p95_ms":32.60605106290394,"tpot_p99_ms":33.795292697127095,"e2e_p50_ms":14934.753101493698,"e2e_p95_ms":17375.76980049923,"e2e_p99_ms":17947.563477410004,"itl_p50_ms":24.548318004235625,"itl_p95_ms":27.168985940807033,"itl_p99_ms":45.33455131750039,"validation_errors":[],"timestamp":"2026-07-17T11:02:45+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":512,"concurrency":128,"num_prompts":640,"warmup_requests":128,"attempt":1,"gain_pct":6.59224,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c128_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c128_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":720,"failed":0,"duration_s":87.33217857498676,"request_tps":8.244383819897273,"input_tps":8442.249031574807,"output_tps":4221.124515787404,"total_tps":12663.37354736221,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":876.7799350025598,"ttft_p95_ms":2024.894075123302,"ttft_p99_ms":2137.7711297254427,"tpot_p50_ms":31.956755282755335,"tpot_p95_ms":37.75039621636339,"tpot_p99_ms":38.710626939200225,"e2e_p50_ms":17466.2616130081,"e2e_p95_ms":19710.75923949829,"e2e_p99_ms":20168.66588307341,"itl_p50_ms":27.541087998542935,"itl_p95_ms":31.771916065190453,"itl_p99_ms":130.73488803987857,"validation_errors":[],"timestamp":"2026-07-17T11:04:52+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":512,"concurrency":144,"num_prompts":720,"warmup_requests":144,"attempt":1,"gain_pct":-0.883566,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c144_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c144_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":800,"failed":0,"duration_s":93.26254364900524,"request_tps":8.577934599455169,"input_tps":8783.805029842093,"output_tps":4391.9025149210465,"total_tps":13175.70754476314,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":1114.2571230011526,"ttft_p95_ms":2203.1496331066587,"ttft_p99_ms":2348.779039189685,"tpot_p50_ms":33.47677020349794,"tpot_p95_ms":39.39110646253304,"tpot_p99_ms":40.5938739798712,"e2e_p50_ms":18631.195646506967,"e2e_p95_ms":20653.001078599475,"e2e_p99_ms":21399.8434732217,"itl_p50_ms":29.37418149667792,"itl_p95_ms":32.57275966461748,"itl_p99_ms":92.88020376232456,"validation_errors":[],"timestamp":"2026-07-17T11:07:08+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":512,"concurrency":160,"num_prompts":800,"warmup_requests":160,"attempt":1,"gain_pct":4.045794,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c160_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c160_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":880,"failed":0,"duration_s":95.42081438101013,"request_tps":9.222306534570201,"input_tps":9443.641891399886,"output_tps":4721.820945699943,"total_tps":14165.462837099829,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":1530.3487765195314,"ttft_p95_ms":2865.3408088488504,"ttft_p99_ms":4100.4959449212765,"tpot_p50_ms":33.58741265753172,"tpot_p95_ms":38.977056207428525,"tpot_p99_ms":39.83865524454675,"e2e_p50_ms":18500.136813003337,"e2e_p95_ms":21500.977623886138,"e2e_p99_ms":21558.581669374253,"itl_p50_ms":30.594480500440113,"itl_p95_ms":33.045402250718325,"itl_p99_ms":45.76839937217313,"validation_errors":[],"timestamp":"2026-07-17T11:09:28+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":512,"concurrency":176,"num_prompts":880,"warmup_requests":176,"attempt":1,"gain_pct":7.511971,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c176_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c176_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":960,"failed":0,"duration_s":98.77470457099844,"request_tps":9.719087535310823,"input_tps":9952.345636158283,"output_tps":4976.1728180791415,"total_tps":14928.518454237426,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":2059.0169335046085,"ttft_p95_ms":3545.7481926176115,"ttft_p99_ms":5457.606031113246,"tpot_p50_ms":33.58695338359545,"tpot_p95_ms":40.729495923593795,"tpot_p99_ms":42.09451902915809,"e2e_p50_ms":19161.39041200222,"e2e_p95_ms":22444.457915097883,"e2e_p99_ms":22488.2156829405,"itl_p50_ms":31.690582502051257,"itl_p95_ms":34.41651005850871,"itl_p99_ms":44.05913534195856,"validation_errors":[],"timestamp":"2026-07-17T11:11:51+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":512,"concurrency":192,"num_prompts":960,"warmup_requests":192,"attempt":1,"gain_pct":5.386733,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c192_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c192_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":1040,"failed":0,"duration_s":102.64350850699702,"request_tps":10.13215560464893,"input_tps":10375.327339160503,"output_tps":5187.663669580252,"total_tps":15562.991008740757,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":1675.4454460024135,"ttft_p95_ms":2852.8699511443847,"ttft_p99_ms":3791.8741921754554,"tpot_p50_ms":36.247211884552975,"tpot_p95_ms":42.10499577801376,"tpot_p99_ms":43.210107844231565,"e2e_p50_ms":20412.007866994827,"e2e_p95_ms":23048.938938090578,"e2e_p99_ms":23236.044127106434,"itl_p50_ms":32.65585549524985,"itl_p95_ms":36.175669117073994,"itl_p99_ms":58.31260999810127,"validation_errors":[],"timestamp":"2026-07-17T11:14:15+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":512,"concurrency":208,"num_prompts":1040,"warmup_requests":208,"attempt":1,"gain_pct":4.25007,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c208_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c208_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":1120,"failed":0,"duration_s":105.60158397798659,"request_tps":10.60590151974872,"input_tps":10860.44315622269,"output_tps":5430.221578111345,"total_tps":16290.664734334032,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":2526.6679620108334,"ttft_p95_ms":4162.4875661480355,"ttft_p99_ms":6234.60898360092,"tpot_p50_ms":35.58585244226825,"tpot_p95_ms":42.14860633296533,"tpot_p99_ms":44.171051645715025,"e2e_p50_ms":20469.466816502973,"e2e_p95_ms":23580.638353075483,"e2e_p99_ms":23631.842883151257,"itl_p50_ms":33.66583300521597,"itl_p95_ms":36.95787015167297,"itl_p99_ms":46.25044279382556,"validation_errors":[],"timestamp":"2026-07-17T11:16:42+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":512,"concurrency":224,"num_prompts":1120,"warmup_requests":224,"attempt":1,"gain_pct":4.675668,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c224_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c224_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":63.51913072701427,"request_tps":1.259463079616367,"input_tps":1289.6901935271599,"output_tps":1289.6901935271599,"total_tps":2579.3803870543197,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":367.40205649402924,"ttft_p95_ms":498.44118639448413,"ttft_p99_ms":627.5793008494655,"tpot_p50_ms":12.039020475562191,"tpot_p95_ms":12.509143239537035,"tpot_p99_ms":12.74743081142403,"e2e_p50_ms":12637.061846005963,"e2e_p95_ms":13224.646402543294,"e2e_p99_ms":13416.498491202074,"itl_p50_ms":11.277054509264417,"itl_p95_ms":11.78294361452572,"itl_p99_ms":14.099022786540447,"validation_errors":[],"timestamp":"2026-07-17T11:18:27+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":1024,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c16_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c16_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":82.9914682850067,"request_tps":1.927909016509179,"input_tps":1974.1788329053993,"output_tps":1974.1788329053993,"total_tps":3948.3576658107986,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":466.22276000562124,"ttft_p95_ms":689.1961883215116,"ttft_p99_ms":696.7751291953027,"tpot_p50_ms":15.180216902241185,"tpot_p95_ms":17.952125711435777,"tpot_p99_ms":18.175321098262337,"e2e_p50_ms":16094.844090999686,"e2e_p95_ms":18835.460561404758,"e2e_p99_ms":19085.000722136756,"itl_p50_ms":14.39011150796432,"itl_p95_ms":16.032203413487874,"itl_p99_ms":28.48148402030298,"validation_errors":[],"timestamp":"2026-07-17T11:20:33+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":1024,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":53.073881,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c32_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c32_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":91.89484773899312,"request_tps":2.611680697068748,"input_tps":2674.361033798398,"output_tps":2674.361033798398,"total_tps":5348.722067596796,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":564.9962780007627,"ttft_p95_ms":898.8940785071463,"ttft_p99_ms":923.7610729740118,"tpot_p50_ms":17.152346113885255,"tpot_p95_ms":18.56830279944224,"tpot_p99_ms":18.694775614060504,"e2e_p50_ms":18165.261703994474,"e2e_p95_ms":19445.50691089971,"e2e_p99_ms":19560.15232453239,"itl_p50_ms":16.65646248147823,"itl_p95_ms":18.10005598672433,"itl_p99_ms":23.477220482891425,"validation_errors":[],"timestamp":"2026-07-17T11:22:46+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":1024,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":35.46701,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c48_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c48_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":103.8167037999956,"request_tps":3.0823556160720025,"input_tps":3156.3321508577305,"output_tps":3156.3321508577305,"total_tps":6312.664301715461,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":642.9865699901711,"ttft_p95_ms":1096.3199352569063,"ttft_p99_ms":1113.629796600726,"tpot_p50_ms":19.30150954497585,"tpot_p95_ms":20.722841697705253,"tpot_p99_ms":20.79091756698524,"e2e_p50_ms":20524.21678698738,"e2e_p95_ms":21641.203278007742,"e2e_p99_ms":21668.588735210942,"itl_p50_ms":18.783036503009498,"itl_p95_ms":20.419597659201827,"itl_p99_ms":27.942887063836643,"validation_errors":[],"timestamp":"2026-07-17T11:25:14+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":1024,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":18.021917,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c64_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c64_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":400,"failed":0,"duration_s":114.55278295499738,"request_tps":3.491840090494719,"input_tps":3575.6442526665924,"output_tps":3575.6442526665924,"total_tps":7151.288505333185,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":754.476385001908,"ttft_p95_ms":1352.5070023009903,"ttft_p99_ms":1361.9045013695722,"tpot_p50_ms":21.107044719948906,"tpot_p95_ms":23.62676638417986,"tpot_p99_ms":23.835345469669527,"e2e_p50_ms":22599.75992050022,"e2e_p95_ms":24671.691669807464,"e2e_p99_ms":24999.842233831878,"itl_p50_ms":20.437672501429915,"itl_p95_ms":21.961590184946544,"itl_p99_ms":30.303989916574213,"validation_errors":[],"timestamp":"2026-07-17T11:27:55+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":1024,"concurrency":80,"num_prompts":400,"warmup_requests":80,"attempt":1,"gain_pct":13.28479,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c80_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c80_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":480,"failed":0,"duration_s":124.51585449799313,"request_tps":3.854930779178296,"input_tps":3947.449117878575,"output_tps":3947.449117878575,"total_tps":7894.89823575715,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":564.6702459926018,"ttft_p95_ms":1480.8017613046102,"ttft_p99_ms":1506.0774685197975,"tpot_p50_ms":23.227364722383165,"tpot_p95_ms":25.05785948416525,"tpot_p99_ms":25.16105005860162,"e2e_p50_ms":24994.347111001844,"e2e_p95_ms":26062.852313298208,"e2e_p99_ms":26148.282454059805,"itl_p50_ms":21.89736549917143,"itl_p95_ms":24.27678494277643,"itl_p99_ms":67.3719594374415,"validation_errors":[],"timestamp":"2026-07-17T11:30:45+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":1024,"concurrency":96,"num_prompts":480,"warmup_requests":96,"attempt":1,"gain_pct":10.398262,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c96_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c96_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":560,"failed":0,"duration_s":131.99658277598792,"request_tps":4.242534073403847,"input_tps":4344.354891165539,"output_tps":4344.354891165539,"total_tps":8688.709782331078,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":633.751483503147,"ttft_p95_ms":1794.523722787562,"ttft_p99_ms":1826.426068044093,"tpot_p50_ms":25.09367103665773,"tpot_p95_ms":25.971509290940524,"tpot_p99_ms":26.138267132286565,"e2e_p50_ms":26417.66119201202,"e2e_p95_ms":27190.899434716266,"e2e_p99_ms":27242.549373769434,"itl_p50_ms":23.35270399635192,"itl_p95_ms":25.719721865607422,"itl_p99_ms":43.2687379670095,"validation_errors":[],"timestamp":"2026-07-17T11:33:40+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":1024,"concurrency":112,"num_prompts":560,"warmup_requests":112,"attempt":1,"gain_pct":10.054741,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c112_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c112_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":640,"failed":0,"duration_s":140.71737810099148,"request_tps":4.548123399092032,"input_tps":4657.2783606702405,"output_tps":4657.2783606702405,"total_tps":9314.556721340481,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":973.8005065009929,"ttft_p95_ms":1928.1410310446515,"ttft_p99_ms":2510.5340445923503,"tpot_p50_ms":26.322691887582973,"tpot_p95_ms":28.862811348948426,"tpot_p99_ms":29.358877789931345,"e2e_p50_ms":27969.385299511487,"e2e_p95_ms":30060.993502358902,"e2e_p99_ms":30461.495746916917,"itl_p50_ms":24.547353488742374,"itl_p95_ms":27.182914565491952,"itl_p99_ms":38.801717855967475,"validation_errors":[],"timestamp":"2026-07-17T11:36:50+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":1024,"concurrency":128,"num_prompts":640,"warmup_requests":128,"attempt":1,"gain_pct":7.20299,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c128_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c128_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":720,"failed":0,"duration_s":156.9156819479831,"request_tps":4.588451524167463,"input_tps":4698.574360747482,"output_tps":4698.574360747482,"total_tps":9397.148721494965,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":1185.5350005062064,"ttft_p95_ms":2055.3580945983413,"ttft_p99_ms":2132.7104762845556,"tpot_p50_ms":29.097492674494006,"tpot_p95_ms":32.18649721273755,"tpot_p99_ms":32.71041093950263,"e2e_p50_ms":30918.186744500417,"e2e_p95_ms":33572.30204644438,"e2e_p99_ms":34021.672390575695,"itl_p50_ms":27.482185498229228,"itl_p95_ms":30.390618367528063,"itl_p99_ms":41.57202276634108,"validation_errors":[],"timestamp":"2026-07-17T11:40:11+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":1024,"concurrency":144,"num_prompts":720,"warmup_requests":144,"attempt":1,"gain_pct":0.886698,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c144_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c144_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":800,"failed":0,"duration_s":167.82545202801703,"request_tps":4.7668574124647485,"input_tps":4881.261990363902,"output_tps":4881.261990363902,"total_tps":9762.523980727805,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":1091.948281507939,"ttft_p95_ms":2311.141635873355,"ttft_p99_ms":2338.189083880279,"tpot_p50_ms":31.51212833967548,"tpot_p95_ms":33.8702887426264,"tpot_p99_ms":34.49707847118674,"e2e_p50_ms":33414.23558050883,"e2e_p95_ms":35361.761938118434,"e2e_p99_ms":36039.59790250228,"itl_p50_ms":29.37527849280741,"itl_p95_ms":32.10601680184481,"itl_p99_ms":44.49573149642675,"validation_errors":[],"timestamp":"2026-07-17T11:43:44+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":1024,"concurrency":160,"num_prompts":800,"warmup_requests":160,"attempt":1,"gain_pct":3.88815,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c160_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c160_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":880,"failed":0,"duration_s":176.27736623500823,"request_tps":4.992132675880849,"input_tps":5111.943860101989,"output_tps":5111.943860101989,"total_tps":10223.887720203978,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":963.8004709995585,"ttft_p95_ms":2490.8414856603476,"ttft_p99_ms":2617.8159483944182,"tpot_p50_ms":33.11914145795834,"tpot_p95_ms":35.999365559618255,"tpot_p99_ms":36.49040766047095,"e2e_p50_ms":35149.62339650083,"e2e_p95_ms":37387.38809595234,"e2e_p99_ms":37900.75673066109,"itl_p50_ms":30.638413998531178,"itl_p95_ms":33.749569788051296,"itl_p99_ms":55.03841057216044,"validation_errors":[],"timestamp":"2026-07-17T11:47:24+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":1024,"concurrency":176,"num_prompts":880,"warmup_requests":176,"attempt":1,"gain_pct":4.725865,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c176_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c176_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":960,"failed":0,"duration_s":181.73432302399306,"request_tps":5.282436383100061,"input_tps":5409.214856294462,"output_tps":5409.214856294462,"total_tps":10818.429712588924,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":1095.2972534869332,"ttft_p95_ms":2687.3316675002566,"ttft_p99_ms":2726.193291565286,"tpot_p50_ms":33.728205277127024,"tpot_p95_ms":36.92941987541335,"tpot_p99_ms":37.44660826187007,"e2e_p50_ms":36149.10016149224,"e2e_p95_ms":38709.319107998446,"e2e_p99_ms":39173.49836571171,"itl_p50_ms":31.711264004115947,"itl_p95_ms":34.786468303354916,"itl_p99_ms":49.722383872722055,"validation_errors":[],"timestamp":"2026-07-17T11:51:15+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":1024,"concurrency":192,"num_prompts":960,"warmup_requests":192,"attempt":1,"gain_pct":5.815224,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c192_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c192_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":1040,"failed":0,"duration_s":187.24337485601427,"request_tps":5.554268613240578,"input_tps":5687.571059958352,"output_tps":5687.571059958352,"total_tps":11375.142119916703,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":1523.8155984989135,"ttft_p95_ms":2797.5829073257046,"ttft_p99_ms":2911.2851842175583,"tpot_p50_ms":34.846510476541305,"tpot_p95_ms":37.61375029238068,"tpot_p99_ms":38.577849033152894,"e2e_p50_ms":37537.37196449947,"e2e_p95_ms":39544.76858334674,"e2e_p99_ms":40091.48570148478,"itl_p50_ms":32.713250009692274,"itl_p95_ms":36.11344556848052,"itl_p99_ms":52.00197715748837,"validation_errors":[],"timestamp":"2026-07-17T11:55:11+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":1024,"concurrency":208,"num_prompts":1040,"warmup_requests":208,"attempt":1,"gain_pct":5.145963,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c208_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c208_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":1120,"failed":0,"duration_s":192.3536709700129,"request_tps":5.822607878248412,"input_tps":5962.350467326374,"output_tps":5962.350467326374,"total_tps":11924.700934652748,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":2038.3250525046606,"ttft_p95_ms":4371.495058131404,"ttft_p99_ms":5927.081859402824,"tpot_p50_ms":35.16872602443571,"tpot_p95_ms":38.03337669517497,"tpot_p99_ms":39.21989803677016,"e2e_p50_ms":38013.39935348369,"e2e_p95_ms":41020.213708082156,"e2e_p99_ms":41132.49452742195,"itl_p50_ms":33.68230450723786,"itl_p95_ms":37.05497109913267,"itl_p99_ms":48.15273583197259,"validation_errors":[],"timestamp":"2026-07-17T11:59:08+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":1024,"concurrency":224,"num_prompts":1120,"warmup_requests":224,"attempt":1,"gain_pct":4.831226,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c224_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c224_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":121.50820481200935,"request_tps":0.6583917532463877,"input_tps":674.193155324301,"output_tps":1348.386310648602,"total_tps":2022.579465972903,"mean_input_tokens":1024.0,"mean_output_tokens":2048.0,"ttft_p50_ms":335.87208348035347,"ttft_p95_ms":480.24582551734056,"ttft_p99_ms":482.40353398054134,"tpot_p50_ms":11.58433496922427,"tpot_p95_ms":12.18200253109553,"tpot_p99_ms":12.22459982190691,"e2e_p50_ms":24076.282977999654,"e2e_p95_ms":25253.537757396407,"e2e_p99_ms":25342.040554704727,"itl_p50_ms":11.303223989671096,"itl_p95_ms":11.823360703419894,"itl_p99_ms":14.136462160677214,"validation_errors":[],"timestamp":"2026-07-17T12:01:46+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":2048,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c16_i1024_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c16_i1024_o2048_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":155.11598643899197,"request_tps":1.031486203795822,"input_tps":1056.2418726869216,"output_tps":2112.4837453738432,"total_tps":3168.7256180607646,"mean_input_tokens":1024.0,"mean_output_tokens":2048.0,"ttft_p50_ms":420.09857698576525,"ttft_p95_ms":690.900651438278,"ttft_p99_ms":704.4460008933673,"tpot_p50_ms":14.841298048857258,"tpot_p95_ms":15.40320534025909,"tpot_p99_ms":15.506339164005862,"e2e_p50_ms":30720.19556349551,"e2e_p95_ms":31925.695040944265,"e2e_p99_ms":32072.989490621836,"itl_p50_ms":14.402032000361942,"itl_p95_ms":15.808762605593072,"itl_p99_ms":20.50381705717882,"validation_errors":[],"timestamp":"2026-07-17T12:05:06+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":2048,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":56.667546,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c32_i1024_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c32_i1024_o2048_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":178.97790775098838,"request_tps":1.3409476231776691,"input_tps":1373.1303661339332,"output_tps":2746.2607322678664,"total_tps":4119.391098401799,"mean_input_tokens":1024.0,"mean_output_tokens":2048.0,"ttft_p50_ms":432.9410104837734,"ttft_p95_ms":858.9107300416799,"ttft_p99_ms":939.9775815411704,"tpot_p50_ms":17.12117492403483,"tpot_p95_ms":17.901382624374648,"tpot_p99_ms":17.939052847364753,"e2e_p50_ms":35631.46954000695,"e2e_p95_ms":36985.68267620285,"e2e_p99_ms":37156.58327252633,"itl_p50_ms":16.672218014718965,"itl_p95_ms":18.38749873568304,"itl_p99_ms":24.002093135204635,"validation_errors":[],"timestamp":"2026-07-17T12:08:45+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":2048,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":30.001508,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c48_i1024_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c48_i1024_o2048_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":199.94909921800718,"request_tps":1.6004073099179092,"input_tps":1638.817085355939,"output_tps":3277.634170711878,"total_tps":4916.451256067818,"mean_input_tokens":1024.0,"mean_output_tokens":2048.0,"ttft_p50_ms":641.2945089978166,"ttft_p95_ms":1067.1280899681735,"ttft_p99_ms":1110.8432558036293,"tpot_p50_ms":19.10860076502082,"tpot_p95_ms":19.74371664526008,"tpot_p99_ms":19.79567449723523,"e2e_p50_ms":39853.09110399976,"e2e_p95_ms":40866.657878717524,"e2e_p99_ms":40998.64525189303,"itl_p50_ms":18.755261495243758,"itl_p95_ms":20.309530071972404,"itl_p99_ms":26.708575765951537,"validation_errors":[],"timestamp":"2026-07-17T12:12:46+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":2048,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":19.34898,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c64_i1024_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c64_i1024_o2048_a1.log"} +{"status":"COMPLETED","completed":400,"failed":0,"duration_s":219.65963144498528,"request_tps":1.820999140209255,"input_tps":1864.703119574277,"output_tps":3729.406239148554,"total_tps":5594.109358722831,"mean_input_tokens":1024.0,"mean_output_tokens":2048.0,"ttft_p50_ms":756.9974045036361,"ttft_p95_ms":1354.971423446841,"ttft_p99_ms":1379.536875654885,"tpot_p50_ms":20.7828555459258,"tpot_p95_ms":22.62685548815943,"tpot_p99_ms":22.680853655491198,"e2e_p50_ms":43353.58003000147,"e2e_p95_ms":46744.002909734256,"e2e_p99_ms":46961.38500066387,"itl_p50_ms":20.39114950457588,"itl_p95_ms":21.927586793026418,"itl_p99_ms":30.282774748920932,"validation_errors":[],"timestamp":"2026-07-17T12:17:14+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":2048,"concurrency":80,"num_prompts":400,"warmup_requests":80,"attempt":1,"gain_pct":13.783481,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c80_i1024_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c80_i1024_o2048_a1.log"} +{"status":"COMPLETED","completed":480,"failed":0,"duration_s":237.17276905302424,"request_tps":2.023841109232432,"input_tps":2072.4132958540104,"output_tps":4144.826591708021,"total_tps":6217.239887562031,"mean_input_tokens":1024.0,"mean_output_tokens":2048.0,"ttft_p50_ms":662.4216605123365,"ttft_p95_ms":1481.8882920473698,"ttft_p99_ms":1506.2272797242622,"tpot_p50_ms":22.674607325595343,"tpot_p95_ms":23.533127194473494,"tpot_p99_ms":24.00764553533727,"e2e_p50_ms":47629.28250899131,"e2e_p95_ms":48637.14092378359,"e2e_p99_ms":49539.947070998314,"itl_p50_ms":21.83643900207244,"itl_p95_ms":30.00202580733457,"itl_p99_ms":61.919074428442414,"validation_errors":[],"timestamp":"2026-07-17T12:21:54+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":2048,"concurrency":96,"num_prompts":480,"warmup_requests":96,"attempt":1,"gain_pct":11.139048,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c96_i1024_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c96_i1024_o2048_a1.log"} +{"status":"COMPLETED","completed":560,"failed":0,"duration_s":253.11571718897903,"request_tps":2.2124268149729227,"input_tps":2265.525058532273,"output_tps":4531.050117064546,"total_tps":6796.5751755968195,"mean_input_tokens":1024.0,"mean_output_tokens":2048.0,"ttft_p50_ms":1363.8906919950387,"ttft_p95_ms":2012.363130437734,"ttft_p99_ms":2206.334002309013,"tpot_p50_ms":23.72196102735523,"tpot_p95_ms":25.012876845555983,"tpot_p99_ms":25.62764998950479,"e2e_p50_ms":49798.67670450767,"e2e_p95_ms":52574.91115619778,"e2e_p99_ms":53067.79057536129,"itl_p50_ms":23.253974999533966,"itl_p95_ms":43.54032500705237,"itl_p99_ms":130.01960345573053,"validation_errors":[],"timestamp":"2026-07-17T12:26:52+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":2048,"concurrency":112,"num_prompts":560,"warmup_requests":112,"attempt":1,"gain_pct":9.318207,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c112_i1024_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c112_i1024_o2048_a1.log"} +{"status":"COMPLETED","completed":640,"failed":0,"duration_s":267.5772363549913,"request_tps":2.3918327609562424,"input_tps":2449.2367472191922,"output_tps":4898.4734944383845,"total_tps":7347.710241657577,"mean_input_tokens":1024.0,"mean_output_tokens":2048.0,"ttft_p50_ms":1547.0869040000252,"ttft_p95_ms":4550.061467850173,"ttft_p99_ms":5216.532010816445,"tpot_p50_ms":25.183745375432323,"tpot_p95_ms":26.439871320470658,"tpot_p99_ms":26.763618641558864,"e2e_p50_ms":52948.93926900113,"e2e_p95_ms":55886.32589295594,"e2e_p99_ms":55940.47024722473,"itl_p50_ms":24.3510319996858,"itl_p95_ms":38.32686656387527,"itl_p99_ms":163.72143151093,"validation_errors":[],"timestamp":"2026-07-17T12:32:03+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":2048,"concurrency":128,"num_prompts":640,"warmup_requests":128,"attempt":1,"gain_pct":8.109012,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c128_i1024_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c128_i1024_o2048_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":237.58923278699513,"request_tps":0.3367155954904828,"input_tps":344.7967697822544,"output_tps":1379.1870791290175,"total_tps":1723.983848911272,"mean_input_tokens":1024.0,"mean_output_tokens":4096.0,"ttft_p50_ms":319.26360000215936,"ttft_p95_ms":475.90027194528375,"ttft_p99_ms":482.3190818668809,"tpot_p50_ms":11.438556473384645,"tpot_p95_ms":11.79697379201896,"tpot_p99_ms":11.830549752317546,"e2e_p50_ms":47108.02132949175,"e2e_p95_ms":48631.19449486112,"e2e_p99_ms":48778.56543769012,"itl_p50_ms":11.295803997199982,"itl_p95_ms":12.09380598156713,"itl_p99_ms":14.665977490949457,"validation_errors":[],"timestamp":"2026-07-17T12:36:39+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":4096,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c16_i1024_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c16_i1024_o4096_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":304.65760577100446,"request_tps":0.5251797328186969,"input_tps":537.7840464063456,"output_tps":2151.1361856253825,"total_tps":2688.920232031728,"mean_input_tokens":1024.0,"mean_output_tokens":4096.0,"ttft_p50_ms":438.98401799378917,"ttft_p95_ms":723.7082958454266,"ttft_p99_ms":734.046471772308,"tpot_p50_ms":14.529197110255904,"tpot_p95_ms":15.208958870893978,"tpot_p99_ms":15.263608833511178,"e2e_p50_ms":59963.35874400393,"e2e_p95_ms":62778.223518515006,"e2e_p99_ms":63036.78499797009,"itl_p50_ms":14.383824018295854,"itl_p95_ms":16.838179773185388,"itl_p99_ms":34.819416285317885,"validation_errors":[],"timestamp":"2026-07-17T12:42:24+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":4096,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":55.971312,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c32_i1024_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c32_i1024_o4096_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":353.49371192601393,"request_tps":0.6789371123247361,"input_tps":695.2316030205297,"output_tps":2780.926412082119,"total_tps":3476.1580151026483,"mean_input_tokens":1024.0,"mean_output_tokens":4096.0,"ttft_p50_ms":714.1022714931751,"ttft_p95_ms":968.7675628636497,"ttft_p99_ms":987.9859179267078,"tpot_p50_ms":17.020451609036453,"tpot_p95_ms":17.271956082126646,"tpot_p99_ms":17.31209642215835,"e2e_p50_ms":70371.05762201827,"e2e_p95_ms":71590.71162570617,"e2e_p99_ms":71754.88906954008,"itl_p50_ms":16.45139501488302,"itl_p95_ms":32.80737963796126,"itl_p99_ms":142.49236572679365,"validation_errors":[],"timestamp":"2026-07-17T12:48:58+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":4096,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":29.277097,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c48_i1024_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c48_i1024_o4096_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":401.55573480797466,"request_tps":0.7969005850533428,"input_tps":816.026199094623,"output_tps":3264.104796378492,"total_tps":4080.1309954731155,"mean_input_tokens":1024.0,"mean_output_tokens":4096.0,"ttft_p50_ms":760.2415285073221,"ttft_p95_ms":1161.6142262995709,"ttft_p99_ms":1185.4782345207059,"tpot_p50_ms":19.392206928813152,"tpot_p95_ms":20.070994758040484,"tpot_p99_ms":20.312788053281604,"e2e_p50_ms":80095.54935799679,"e2e_p95_ms":82929.46552327194,"e2e_p99_ms":83905.66750780417,"itl_p50_ms":18.44648200494703,"itl_p95_ms":45.271321192558446,"itl_p99_ms":192.77728227723856,"validation_errors":[],"timestamp":"2026-07-17T12:56:19+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":4096,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":17.374727,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c64_i1024_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c64_i1024_o4096_a1.log"} +{"status":"COMPLETED","completed":400,"failed":0,"duration_s":433.6616191670182,"request_tps":0.9223781453574891,"input_tps":944.5152208460688,"output_tps":3778.0608833842753,"total_tps":4722.576104230344,"mean_input_tokens":1024.0,"mean_output_tokens":4096.0,"ttft_p50_ms":925.0847404910019,"ttft_p95_ms":1306.8336107622597,"ttft_p99_ms":1331.506734705472,"tpot_p50_ms":20.790644539075235,"tpot_p95_ms":21.55024844770337,"tpot_p99_ms":21.712793517439746,"e2e_p50_ms":86185.16982051369,"e2e_p95_ms":89146.01335814659,"e2e_p99_ms":89782.01180824748,"itl_p50_ms":19.981495992396958,"itl_p95_ms":60.09086276608283,"itl_p99_ms":179.22479357366686,"validation_errors":[],"timestamp":"2026-07-17T13:04:13+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":4096,"concurrency":80,"num_prompts":400,"warmup_requests":80,"attempt":1,"gain_pct":15.745698,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c80_i1024_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c80_i1024_o4096_a1.log"} +{"status":"COMPLETED","completed":480,"failed":0,"duration_s":480.7195879560022,"request_tps":0.9985031024862917,"input_tps":1022.4671769459627,"output_tps":4089.868707783851,"total_tps":5112.335884729813,"mean_input_tokens":1024.0,"mean_output_tokens":4096.0,"ttft_p50_ms":1061.906506001833,"ttft_p95_ms":1588.3171627909176,"ttft_p99_ms":1614.429443711706,"tpot_p50_ms":22.853942958365014,"tpot_p95_ms":24.107084599156483,"tpot_p99_ms":24.41300426676714,"e2e_p50_ms":94568.09207200422,"e2e_p95_ms":99834.45504019328,"e2e_p99_ms":101179.79810698569,"itl_p50_ms":21.256343490676954,"itl_p95_ms":85.04168531217084,"itl_p99_ms":275.520747169503,"validation_errors":[],"timestamp":"2026-07-17T13:12:56+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":4096,"concurrency":96,"num_prompts":480,"warmup_requests":96,"attempt":1,"gain_pct":8.253118,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c96_i1024_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c96_i1024_o4096_a1.log"} +{"status":"COMPLETED","completed":560,"failed":0,"duration_s":521.4117790439923,"request_tps":1.0740071906828785,"input_tps":1099.7833632592676,"output_tps":4399.1334530370705,"total_tps":5498.916816296339,"mean_input_tokens":1024.0,"mean_output_tokens":4096.0,"ttft_p50_ms":1081.6736779961502,"ttft_p95_ms":1728.9518461329862,"ttft_p99_ms":1760.8406342443777,"tpot_p50_ms":24.982644384126328,"tpot_p95_ms":26.193744934489708,"tpot_p99_ms":26.73113787879916,"e2e_p50_ms":103416.6811085015,"e2e_p95_ms":108326.53737080982,"e2e_p99_ms":110823.84126851073,"itl_p50_ms":22.506901499582455,"itl_p95_ms":98.35611924499906,"itl_p99_ms":241.3524908642284,"validation_errors":[],"timestamp":"2026-07-17T13:22:26+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":4096,"concurrency":112,"num_prompts":560,"warmup_requests":112,"attempt":1,"gain_pct":7.561728,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c112_i1024_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c112_i1024_o4096_a1.log"} +{"status":"COMPLETED","completed":640,"failed":0,"duration_s":579.8847862099938,"request_tps":1.1036675133053702,"input_tps":1130.155533624699,"output_tps":4520.622134498796,"total_tps":5650.7776681234955,"mean_input_tokens":1024.0,"mean_output_tokens":4096.0,"ttft_p50_ms":1615.5440010043094,"ttft_p95_ms":1891.2745572408312,"ttft_p99_ms":2228.790492259437,"tpot_p50_ms":27.660828984735684,"tpot_p95_ms":29.022849598251735,"tpot_p99_ms":29.53528111120055,"e2e_p50_ms":114777.92089250579,"e2e_p95_ms":120144.8195085075,"e2e_p99_ms":122497.63309018075,"itl_p50_ms":0.3519109741318971,"itl_p95_ms":186.9315421572526,"itl_p99_ms":382.68263967183873,"validation_errors":[],"timestamp":"2026-07-17T13:33:00+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":4096,"concurrency":128,"num_prompts":640,"warmup_requests":128,"attempt":1,"gain_pct":2.76165,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c128_i1024_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c128_i1024_o4096_a1.log"} +{"status":"COMPLETED","completed":720,"failed":0,"duration_s":644.2087298780098,"request_tps":1.1176501754894603,"input_tps":1144.4737797012074,"output_tps":4577.8951188048295,"total_tps":5722.368898506037,"mean_input_tokens":1024.0,"mean_output_tokens":4096.0,"ttft_p50_ms":1744.893882991164,"ttft_p95_ms":3172.456429088197,"ttft_p99_ms":4333.137181155907,"tpot_p50_ms":30.722622930528388,"tpot_p95_ms":32.07159924851106,"tpot_p99_ms":32.25490895383563,"e2e_p50_ms":127541.65868698328,"e2e_p95_ms":133089.30121439917,"e2e_p99_ms":133502.30126501265,"itl_p50_ms":0.3190040006302297,"itl_p95_ms":245.7728737033895,"itl_p99_ms":428.470165184699,"validation_errors":[],"timestamp":"2026-07-17T13:44:35+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":4096,"concurrency":144,"num_prompts":720,"warmup_requests":144,"attempt":1,"gain_pct":1.266927,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c144_i1024_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c144_i1024_o4096_a1.log"} +{"status":"COMPLETED","completed":800,"failed":0,"duration_s":707.1316968669998,"request_tps":1.1313309862143928,"input_tps":1158.4829298835382,"output_tps":4633.931719534153,"total_tps":5792.414649417691,"mean_input_tokens":1024.0,"mean_output_tokens":4096.0,"ttft_p50_ms":1921.1181784921791,"ttft_p95_ms":3358.4726150467754,"ttft_p99_ms":4069.3832430554908,"tpot_p50_ms":34.583404436868115,"tpot_p95_ms":35.41830287408908,"tpot_p99_ms":35.62069940976631,"e2e_p50_ms":143749.25434900797,"e2e_p95_ms":146766.47877694195,"e2e_p99_ms":147591.1159169927,"itl_p50_ms":0.3356900124344975,"itl_p95_ms":267.211153407697,"itl_p99_ms":478.5121665309998,"validation_errors":[],"timestamp":"2026-07-17T13:57:11+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":4096,"concurrency":160,"num_prompts":800,"warmup_requests":160,"attempt":1,"gain_pct":1.224069,"plateau_streak":2,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c160_i1024_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c160_i1024_o4096_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":15.847962964995531,"request_tps":5.047967374526393,"input_tps":20676.474366060105,"output_tps":646.1398239393783,"total_tps":21322.614189999484,"mean_input_tokens":4096.0,"mean_output_tokens":128.0,"ttft_p50_ms":918.5048255021684,"ttft_p95_ms":1497.3854605006636,"ttft_p99_ms":1534.2136507018583,"tpot_p50_ms":16.741423389835898,"tpot_p95_ms":21.569492566164612,"tpot_p99_ms":22.96271583879151,"e2e_p50_ms":3266.615799002466,"e2e_p95_ms":3968.9176032086834,"e2e_p99_ms":3977.5278707651887,"itl_p50_ms":11.318468488752842,"itl_p95_ms":13.171324887662193,"itl_p99_ms":171.411670748784,"validation_errors":[],"timestamp":"2026-07-17T13:58:06+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":128,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c16_i4096_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c16_i4096_o128_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":18.160880562994862,"request_tps":8.810145490743475,"input_tps":36086.35593008527,"output_tps":1127.6986228151648,"total_tps":37214.05455290044,"mean_input_tokens":4096.0,"mean_output_tokens":128.0,"ttft_p50_ms":834.5754889887758,"ttft_p95_ms":1445.1430589455413,"ttft_p99_ms":1544.3094951490639,"tpot_p50_ms":17.34702485039698,"tpot_p95_ms":31.598180702013902,"tpot_p99_ms":35.07776605354679,"e2e_p50_ms":3323.178275997634,"e2e_p95_ms":5229.302121825458,"e2e_p99_ms":5239.7153412832995,"itl_p50_ms":14.36973201634828,"itl_p95_ms":15.505047238548286,"itl_p99_ms":137.37467278726405,"validation_errors":[],"timestamp":"2026-07-17T13:59:07+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":128,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":74.528574,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c32_i4096_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c32_i4096_o128_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":24.645151998003712,"request_tps":9.738223567030152,"input_tps":39887.7637305555,"output_tps":1246.4926165798595,"total_tps":41134.256347135364,"mean_input_tokens":4096.0,"mean_output_tokens":128.0,"ttft_p50_ms":776.75594050379,"ttft_p95_ms":1451.4520239128615,"ttft_p99_ms":1746.5871139254887,"tpot_p50_ms":24.92232012594995,"tpot_p95_ms":62.72655403740858,"tpot_p99_ms":67.9862247080786,"e2e_p50_ms":3935.901321005076,"e2e_p95_ms":8978.954380154026,"e2e_p99_ms":9492.129214947345,"itl_p50_ms":16.5937924903119,"itl_p95_ms":34.71068409999132,"itl_p99_ms":487.77646085771266,"validation_errors":[],"timestamp":"2026-07-17T14:00:14+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":128,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":10.534197,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c48_i4096_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c48_i4096_o128_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":25.53172718998394,"request_tps":12.533425475638621,"input_tps":51336.91074821579,"output_tps":1604.2784608817435,"total_tps":52941.18920909754,"mean_input_tokens":4096.0,"mean_output_tokens":128.0,"ttft_p50_ms":1224.2599974997574,"ttft_p95_ms":2934.262477750599,"ttft_p99_ms":3503.5912440580432,"tpot_p50_ms":22.516809303178746,"tpot_p95_ms":55.26107284856876,"tpot_p99_ms":60.09680859506218,"e2e_p50_ms":3895.789340007468,"e2e_p95_ms":8475.184639407962,"e2e_p99_ms":8523.635545754805,"itl_p50_ms":18.596424502902664,"itl_p95_ms":19.72295350424247,"itl_p99_ms":72.32926230848541,"validation_errors":[],"timestamp":"2026-07-17T14:01:17+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":128,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":28.703407,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c64_i4096_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c64_i4096_o128_a1.log"} +{"status":"COMPLETED","completed":400,"failed":0,"duration_s":27.09394760298892,"request_tps":14.763444805506055,"input_tps":60471.0699233528,"output_tps":1889.720935104775,"total_tps":62360.79085845758,"mean_input_tokens":4096.0,"mean_output_tokens":128.0,"ttft_p50_ms":1386.3868770131376,"ttft_p95_ms":5319.312060165976,"ttft_p99_ms":6251.451821199147,"tpot_p50_ms":23.498859629814156,"tpot_p95_ms":55.16993636547269,"tpot_p99_ms":68.08747088875782,"e2e_p50_ms":4172.036694988492,"e2e_p95_ms":9568.306554637058,"e2e_p99_ms":10317.921219949785,"itl_p50_ms":20.286371000111103,"itl_p95_ms":21.174113269080408,"itl_p99_ms":50.14902021066526,"validation_errors":[],"timestamp":"2026-07-17T14:02:23+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":128,"concurrency":80,"num_prompts":400,"warmup_requests":80,"attempt":1,"gain_pct":17.792577,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c80_i4096_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c80_i4096_o128_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":17.56048169499263,"request_tps":4.555683687356479,"input_tps":18660.08038341214,"output_tps":1166.2550239632587,"total_tps":19826.3354073754,"mean_input_tokens":4096.0,"mean_output_tokens":256.0,"ttft_p50_ms":474.27257148956414,"ttft_p95_ms":542.6969805877889,"ttft_p99_ms":686.9026716076769,"tpot_p50_ms":11.420457086277048,"tpot_p95_ms":12.983578241946104,"tpot_p99_ms":13.166030882427455,"e2e_p50_ms":3417.084447501111,"e2e_p95_ms":3855.7598280618545,"e2e_p99_ms":3998.260515387519,"itl_p50_ms":11.315975498291664,"itl_p95_ms":11.635743505030405,"itl_p99_ms":13.40927139885025,"validation_errors":[],"timestamp":"2026-07-17T14:03:17+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":256,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c16_i4096_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c16_i4096_o256_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":22.48068160499679,"request_tps":7.117221924642923,"input_tps":29152.141003337412,"output_tps":1822.0088127085883,"total_tps":30974.149816046,"mean_input_tokens":4096.0,"mean_output_tokens":256.0,"ttft_p50_ms":695.2051630069036,"ttft_p95_ms":830.5566305454704,"ttft_p99_ms":846.650164881139,"tpot_p50_ms":14.730117199988122,"tpot_p95_ms":15.880968385962682,"tpot_p99_ms":16.679516542290894,"e2e_p50_ms":4461.93809149554,"e2e_p95_ms":4749.65935726068,"e2e_p99_ms":4759.746165146353,"itl_p50_ms":14.381551009137183,"itl_p95_ms":14.897704383474775,"itl_p99_ms":17.10730397840964,"validation_errors":[],"timestamp":"2026-07-17T14:04:16+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":256,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":56.227307,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c32_i4096_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c32_i4096_o256_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":26.624048858007882,"request_tps":9.014406534482214,"input_tps":36923.00916523915,"output_tps":2307.688072827447,"total_tps":39230.6972380666,"mean_input_tokens":4096.0,"mean_output_tokens":256.0,"ttft_p50_ms":773.6569099943154,"ttft_p95_ms":1056.6721132679959,"ttft_p99_ms":1066.4829467225354,"tpot_p50_ms":17.707814454893104,"tpot_p95_ms":19.09204749613612,"tpot_p99_ms":19.48768090508997,"e2e_p50_ms":5293.400573005783,"e2e_p95_ms":5648.688763352402,"e2e_p99_ms":5668.732196038181,"itl_p50_ms":16.564051489694975,"itl_p95_ms":17.132832751667593,"itl_p99_ms":20.73232045542708,"validation_errors":[],"timestamp":"2026-07-17T14:05:27+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":256,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":26.656252,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c48_i4096_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c48_i4096_o256_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":32.797805067006266,"request_tps":9.75675046992433,"input_tps":39963.64992481006,"output_tps":2497.7281203006287,"total_tps":42461.37804511069,"mean_input_tokens":4096.0,"mean_output_tokens":256.0,"ttft_p50_ms":815.6206430139719,"ttft_p95_ms":1604.5205851551145,"ttft_p99_ms":1768.517577102175,"tpot_p50_ms":21.85023636477269,"tpot_p95_ms":24.87825669807624,"tpot_p99_ms":27.04143827625518,"e2e_p50_ms":6567.792797010043,"e2e_p95_ms":7342.777989144092,"e2e_p99_ms":7747.63391412358,"itl_p50_ms":18.63369799684733,"itl_p95_ms":19.462999238749035,"itl_p99_ms":120.66521777392904,"validation_errors":[],"timestamp":"2026-07-17T14:06:36+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":256,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":8.235084,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c64_i4096_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c64_i4096_o256_a1.log"} +{"status":"COMPLETED","completed":400,"failed":0,"duration_s":36.26023676802288,"request_tps":11.031367571012426,"input_tps":45184.4815708669,"output_tps":2824.030098179181,"total_tps":48008.51166904608,"mean_input_tokens":4096.0,"mean_output_tokens":256.0,"ttft_p50_ms":901.2035854975693,"ttft_p95_ms":1514.5296838207278,"ttft_p99_ms":1671.717134215287,"tpot_p50_ms":24.11175481763933,"tpot_p95_ms":28.678945898381972,"tpot_p99_ms":29.118352007584228,"e2e_p50_ms":7213.9586150005925,"e2e_p95_ms":8129.332813304789,"e2e_p99_ms":8193.646707386652,"itl_p50_ms":20.280605502193794,"itl_p95_ms":21.2564844157896,"itl_p99_ms":187.3273529010475,"validation_errors":[],"timestamp":"2026-07-17T14:07:51+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":256,"concurrency":80,"num_prompts":400,"warmup_requests":80,"attempt":1,"gain_pct":13.063951,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c80_i4096_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c80_i4096_o256_a1.log"} +{"status":"COMPLETED","completed":480,"failed":0,"duration_s":54.39254291699035,"request_tps":8.824739095808381,"input_tps":36146.13133643113,"output_tps":2259.1332085269455,"total_tps":38405.264544958074,"mean_input_tokens":4096.0,"mean_output_tokens":256.0,"ttft_p50_ms":1244.847360998392,"ttft_p95_ms":14204.196976510866,"ttft_p99_ms":18104.64513344486,"tpot_p50_ms":24.21766170585875,"tpot_p95_ms":80.28262706874062,"tpot_p99_ms":91.26408919232536,"e2e_p50_ms":7511.609213499469,"e2e_p95_ms":24498.75134659813,"e2e_p99_ms":24927.128775377932,"itl_p50_ms":21.639740996761248,"itl_p95_ms":22.501951592857946,"itl_p99_ms":40.21485055913205,"validation_errors":[],"timestamp":"2026-07-17T14:09:26+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":256,"concurrency":96,"num_prompts":480,"warmup_requests":96,"attempt":1,"gain_pct":-20.003218,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c96_i4096_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c96_i4096_o256_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":33.230836761998944,"request_tps":2.4074025151086125,"input_tps":9860.720701884877,"output_tps":1232.5900877356096,"total_tps":11093.310789620487,"mean_input_tokens":4096.0,"mean_output_tokens":512.0,"ttft_p50_ms":489.8299534979742,"ttft_p95_ms":565.1824474916793,"ttft_p99_ms":736.3204278057674,"tpot_p50_ms":11.601937603707327,"tpot_p95_ms":13.766420867091657,"tpot_p99_ms":13.773401378692787,"e2e_p50_ms":6375.819210486952,"e2e_p95_ms":7513.549435901223,"e2e_p99_ms":7526.219469298376,"itl_p50_ms":11.3062440068461,"itl_p95_ms":11.677152120682877,"itl_p99_ms":13.645650164398823,"validation_errors":[],"timestamp":"2026-07-17T14:10:33+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":512,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c16_i4096_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c16_i4096_o512_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":44.446463392989244,"request_tps":3.5998364725963232,"input_tps":14744.93019175454,"output_tps":1843.1162739693175,"total_tps":16588.046465723855,"mean_input_tokens":4096.0,"mean_output_tokens":512.0,"ttft_p50_ms":529.5076589973178,"ttft_p95_ms":998.7035005033233,"ttft_p99_ms":1243.6321408639196,"tpot_p50_ms":16.29834187181973,"tpot_p95_ms":17.41833037071929,"tpot_p99_ms":17.7151881269123,"e2e_p50_ms":8941.578270489117,"e2e_p95_ms":9437.361427397991,"e2e_p99_ms":9482.45473296236,"itl_p50_ms":14.360287503222935,"itl_p95_ms":14.955729366920425,"itl_p99_ms":78.04298652248791,"validation_errors":[],"timestamp":"2026-07-17T14:12:01+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":512,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":49.531973,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c32_i4096_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c32_i4096_o512_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":47.81152007699711,"request_tps":5.01971072271906,"input_tps":20560.735120257268,"output_tps":2570.0918900321585,"total_tps":23130.827010289428,"mean_input_tokens":4096.0,"mean_output_tokens":512.0,"ttft_p50_ms":787.9730410058983,"ttft_p95_ms":1091.6863420978186,"ttft_p99_ms":1106.1781612902996,"tpot_p50_ms":17.004369450115675,"tpot_p95_ms":17.74832996046658,"tpot_p99_ms":17.94997432976077,"e2e_p50_ms":9536.782303999644,"e2e_p95_ms":9851.541960981558,"e2e_p99_ms":9869.002870151016,"itl_p50_ms":16.52914599981159,"itl_p95_ms":17.148341004212853,"itl_p99_ms":21.65380945225479,"validation_errors":[],"timestamp":"2026-07-17T14:13:29+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":512,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":39.442743,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c48_i4096_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c48_i4096_o512_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":56.60688755300362,"request_tps":5.653022341148317,"input_tps":23154.779509343505,"output_tps":2894.347438667938,"total_tps":26049.126948011442,"mean_input_tokens":4096.0,"mean_output_tokens":512.0,"ttft_p50_ms":842.2787619929295,"ttft_p95_ms":1320.7603217990254,"ttft_p99_ms":1400.5812642670937,"tpot_p50_ms":20.408940776915347,"tpot_p95_ms":22.361783146152092,"tpot_p99_ms":22.597852345280817,"e2e_p50_ms":11319.821633500396,"e2e_p95_ms":12111.558087215237,"e2e_p99_ms":12309.208046818967,"itl_p50_ms":18.588499500765465,"itl_p95_ms":19.41587930195965,"itl_p99_ms":30.49774844577768,"validation_errors":[],"timestamp":"2026-07-17T14:15:04+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":512,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":12.616496,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c64_i4096_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c64_i4096_o512_a1.log"} +{"status":"COMPLETED","completed":400,"failed":0,"duration_s":61.25990155900945,"request_tps":6.529556689128768,"input_tps":26745.064198671433,"output_tps":3343.133024833929,"total_tps":30088.19722350536,"mean_input_tokens":4096.0,"mean_output_tokens":512.0,"ttft_p50_ms":966.1473450105404,"ttft_p95_ms":1550.7498725070034,"ttft_p99_ms":1711.9882592427894,"tpot_p50_ms":22.176727155591873,"tpot_p95_ms":23.174470422206582,"tpot_p99_ms":23.869971722772107,"e2e_p50_ms":12179.847922510817,"e2e_p95_ms":13087.83916822722,"e2e_p99_ms":13116.638996628753,"itl_p50_ms":20.221174490870908,"itl_p95_ms":21.14378640835639,"itl_p99_ms":30.082881455309693,"validation_errors":[],"timestamp":"2026-07-17T14:16:51+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":512,"concurrency":80,"num_prompts":400,"warmup_requests":80,"attempt":1,"gain_pct":15.505588,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c80_i4096_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c80_i4096_o512_a1.log"} +{"status":"COMPLETED","completed":480,"failed":0,"duration_s":66.63744170599966,"request_tps":7.203157679998142,"input_tps":29504.13385727239,"output_tps":3688.016732159049,"total_tps":33192.15058943144,"mean_input_tokens":4096.0,"mean_output_tokens":512.0,"ttft_p50_ms":1038.9702360116644,"ttft_p95_ms":1784.9445949366782,"ttft_p99_ms":1796.9048791241948,"tpot_p50_ms":23.80630241686122,"tpot_p95_ms":26.015279392441624,"tpot_p99_ms":26.605561305518755,"e2e_p50_ms":13048.204250007984,"e2e_p95_ms":14176.79350890538,"e2e_p99_ms":14489.614698581281,"itl_p50_ms":21.648395995725878,"itl_p95_ms":22.806775002391078,"itl_p99_ms":38.328300165594555,"validation_errors":[],"timestamp":"2026-07-17T14:18:41+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":512,"concurrency":96,"num_prompts":480,"warmup_requests":96,"attempt":1,"gain_pct":10.316183,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c96_i4096_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c96_i4096_o512_a1.log"} +{"status":"COMPLETED","completed":560,"failed":0,"duration_s":87.33443516699481,"request_tps":6.412132842322815,"input_tps":26264.09612215425,"output_tps":3283.012015269281,"total_tps":29547.10813742353,"mean_input_tokens":4096.0,"mean_output_tokens":512.0,"ttft_p50_ms":1450.9745239920449,"ttft_p95_ms":13841.410758603874,"ttft_p99_ms":18812.87264820479,"tpot_p50_ms":24.63163014481627,"tpot_p95_ms":56.941899299021735,"tpot_p99_ms":59.786891657382945,"e2e_p50_ms":14065.18239050638,"e2e_p95_ms":31192.849514413683,"e2e_p99_ms":31238.505908496445,"itl_p50_ms":23.070539988111705,"itl_p95_ms":24.5007082077791,"itl_p99_ms":31.08630002534471,"validation_errors":[],"timestamp":"2026-07-17T14:20:49+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":512,"concurrency":112,"num_prompts":560,"warmup_requests":112,"attempt":1,"gain_pct":-10.98164,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c112_i4096_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c112_i4096_o512_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":77.46474870399106,"request_tps":1.032727806369019,"input_tps":4230.053094887502,"output_tps":1057.5132737218755,"total_tps":5287.566368609378,"mean_input_tokens":4096.0,"mean_output_tokens":1024.0,"ttft_p50_ms":1094.7583690140164,"ttft_p95_ms":3414.8552765866043,"ttft_p99_ms":3617.946124926965,"tpot_p50_ms":13.672541198926659,"tpot_p95_ms":15.188831005572958,"tpot_p99_ms":15.531792184235268,"e2e_p50_ms":15485.37390299316,"e2e_p95_ms":17318.8515632879,"e2e_p99_ms":17327.747802647064,"itl_p50_ms":11.29308000963647,"itl_p95_ms":11.673299536050763,"itl_p99_ms":13.867536908073816,"validation_errors":[],"timestamp":"2026-07-17T14:22:51+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":1024,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c16_i4096_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c16_i4096_o1024_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":94.62563979899278,"request_tps":1.6908736399550672,"input_tps":6925.818429255955,"output_tps":1731.4546073139888,"total_tps":8657.273036569944,"mean_input_tokens":4096.0,"mean_output_tokens":1024.0,"ttft_p50_ms":960.1077939878451,"ttft_p95_ms":3661.747044342336,"ttft_p99_ms":3786.759829660004,"tpot_p50_ms":15.84232367008398,"tpot_p95_ms":20.72497352072433,"tpot_p99_ms":21.52517507838208,"e2e_p50_ms":18389.304656506283,"e2e_p95_ms":22299.681879887055,"e2e_p99_ms":22873.022122863622,"itl_p50_ms":14.334641004097648,"itl_p95_ms":14.835088890686166,"itl_p99_ms":17.663060046033927,"validation_errors":[],"timestamp":"2026-07-17T14:25:10+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":1024,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":63.728877,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c32_i4096_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c32_i4096_o1024_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":107.77338312499342,"request_tps":2.2268949256390402,"input_tps":9121.361615417509,"output_tps":2280.340403854377,"total_tps":11401.702019271886,"mean_input_tokens":4096.0,"mean_output_tokens":1024.0,"ttft_p50_ms":999.0450734912883,"ttft_p95_ms":5032.537865174527,"ttft_p99_ms":5450.208466525654,"tpot_p50_ms":17.58022693597554,"tpot_p95_ms":26.268031297694883,"tpot_p99_ms":27.425070844081077,"e2e_p50_ms":19157.92318501917,"e2e_p95_ms":28364.209315250584,"e2e_p99_ms":30955.708915400028,"itl_p50_ms":16.494632509420626,"itl_p95_ms":17.634235534933396,"itl_p99_ms":22.43540314550046,"validation_errors":[],"timestamp":"2026-07-17T14:27:36+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":1024,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":31.700848,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c48_i4096_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c48_i4096_o1024_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":119.13816821700311,"request_tps":0.6714892565267979,"input_tps":2750.4199947337643,"output_tps":1375.2099973668821,"total_tps":4125.629992100646,"mean_input_tokens":4096.0,"mean_output_tokens":2048.0,"ttft_p50_ms":458.6572289990727,"ttft_p95_ms":630.588803687715,"ttft_p99_ms":737.8619194825296,"tpot_p50_ms":11.354561204196893,"tpot_p95_ms":11.624407314237576,"tpot_p99_ms":11.656648568209269,"e2e_p50_ms":23721.98651099461,"e2e_p95_ms":24146.23811440397,"e2e_p99_ms":24361.2186797685,"itl_p50_ms":11.282145002041943,"itl_p95_ms":11.730588162026834,"itl_p99_ms":13.530634298804227,"validation_errors":[],"timestamp":"2026-07-17T14:30:14+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":2048,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c16_i4096_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c16_i4096_o2048_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":153.14147126598982,"request_tps":1.0447855742622303,"input_tps":4279.441712178095,"output_tps":2139.7208560890476,"total_tps":6419.162568267142,"mean_input_tokens":4096.0,"mean_output_tokens":2048.0,"ttft_p50_ms":537.0585850032512,"ttft_p95_ms":1083.0751357236295,"ttft_p99_ms":1087.4136492109392,"tpot_p50_ms":14.618930614562036,"tpot_p95_ms":14.997450184393172,"tpot_p99_ms":15.122292630295977,"e2e_p50_ms":30422.24122751213,"e2e_p95_ms":31094.485713257745,"e2e_p99_ms":31300.7005869539,"itl_p50_ms":14.322812494356185,"itl_p95_ms":15.286787487275433,"itl_p99_ms":19.505763458437286,"validation_errors":[],"timestamp":"2026-07-17T14:33:24+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":2048,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":55.592299,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c32_i4096_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c32_i4096_o2048_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":177.28022358298767,"request_tps":1.353788906339303,"input_tps":5545.119360365785,"output_tps":2772.5596801828924,"total_tps":8317.679040548677,"mean_input_tokens":4096.0,"mean_output_tokens":2048.0,"ttft_p50_ms":576.9537714804756,"ttft_p95_ms":1285.2179007837542,"ttft_p99_ms":1365.3415781978401,"tpot_p50_ms":16.813456695169407,"tpot_p95_ms":17.48565074548067,"tpot_p99_ms":17.501511701643906,"e2e_p50_ms":35257.671866507735,"e2e_p95_ms":36319.83156185015,"e2e_p99_ms":36372.916622001794,"itl_p50_ms":16.46122349484358,"itl_p95_ms":17.83509639062686,"itl_p99_ms":23.278975597932007,"validation_errors":[],"timestamp":"2026-07-17T14:37:07+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":2048,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":29.575766,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c48_i4096_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c48_i4096_o2048_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":216.5515758000256,"request_tps":1.4777080185992448,"input_tps":6052.692044182507,"output_tps":3026.3460220912534,"total_tps":9079.03806627376,"mean_input_tokens":4096.0,"mean_output_tokens":2048.0,"ttft_p50_ms":1123.5076334996847,"ttft_p95_ms":3566.171070134442,"ttft_p99_ms":3796.0118225886254,"tpot_p50_ms":19.475296204934136,"tpot_p95_ms":24.496322752865986,"tpot_p99_ms":25.29702195867685,"e2e_p50_ms":41228.981135980575,"e2e_p95_ms":52868.20083618222,"e2e_p99_ms":53506.109366860765,"itl_p50_ms":18.483492007362656,"itl_p95_ms":20.15238746535033,"itl_p99_ms":26.60390306613408,"validation_errors":[],"timestamp":"2026-07-17T14:41:31+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":2048,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":9.153503,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c64_i4096_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c64_i4096_o2048_a1.log"} +{"status":"COMPLETED","completed":400,"failed":0,"duration_s":234.67915646597976,"request_tps":1.7044547373681478,"input_tps":6981.446604259933,"output_tps":3490.7233021299667,"total_tps":10472.1699063899,"mean_input_tokens":4096.0,"mean_output_tokens":2048.0,"ttft_p50_ms":1195.1033544901293,"ttft_p95_ms":2999.6021315775197,"ttft_p99_ms":4507.029714495,"tpot_p50_ms":21.073762774788506,"tpot_p95_ms":27.68087070723621,"tpot_p99_ms":28.4631430518515,"e2e_p50_ms":44198.868214007234,"e2e_p95_ms":57774.28339962348,"e2e_p99_ms":60132.53849553672,"itl_p50_ms":20.116301006055437,"itl_p95_ms":21.345270771416832,"itl_p99_ms":29.67329251405318,"validation_errors":[],"timestamp":"2026-07-17T14:46:08+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":2048,"concurrency":80,"num_prompts":400,"warmup_requests":80,"attempt":1,"gain_pct":15.344487,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c80_i4096_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c80_i4096_o2048_a1.log"} +{"status":"COMPLETED","completed":480,"failed":0,"duration_s":253.64057108201087,"request_tps":1.892441725518743,"input_tps":7751.441307724771,"output_tps":3875.7206538623855,"total_tps":11627.161961587157,"mean_input_tokens":4096.0,"mean_output_tokens":2048.0,"ttft_p50_ms":1688.5416549921501,"ttft_p95_ms":2883.727444292162,"ttft_p99_ms":5115.596701100585,"tpot_p50_ms":22.869307058139654,"tpot_p95_ms":29.911680205813255,"tpot_p99_ms":30.455452814912423,"e2e_p50_ms":48819.89936600439,"e2e_p95_ms":61899.26725349794,"e2e_p99_ms":63761.573402910726,"itl_p50_ms":21.51596249314025,"itl_p95_ms":31.517466163495524,"itl_p99_ms":76.01840425137306,"validation_errors":[],"timestamp":"2026-07-17T14:51:12+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":2048,"concurrency":96,"num_prompts":480,"warmup_requests":96,"attempt":1,"gain_pct":11.029157,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c96_i4096_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c96_i4096_o2048_a1.log"} +{"status":"COMPLETED","completed":560,"failed":0,"duration_s":365.67380005601444,"request_tps":1.5314195326933961,"input_tps":6272.694405912151,"output_tps":3136.3472029560753,"total_tps":9409.041608868225,"mean_input_tokens":4096.0,"mean_output_tokens":2048.0,"ttft_p50_ms":5682.160876996932,"ttft_p95_ms":23459.617758137738,"ttft_p99_ms":25349.947154100515,"tpot_p50_ms":31.570926079135322,"tpot_p95_ms":38.69527628066125,"tpot_p99_ms":40.116158825897045,"e2e_p50_ms":72797.50519299705,"e2e_p95_ms":85977.25149014295,"e2e_p99_ms":85985.25149417488,"itl_p50_ms":22.918733506230637,"itl_p95_ms":42.497572152933564,"itl_p99_ms":122.46892816619963,"validation_errors":[],"timestamp":"2026-07-17T14:58:04+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":2048,"concurrency":112,"num_prompts":560,"warmup_requests":112,"attempt":1,"gain_pct":-19.077057,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c112_i4096_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c112_i4096_o2048_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":251.59067001601215,"request_tps":0.31797681525673627,"input_tps":1302.4330352915918,"output_tps":1302.4330352915918,"total_tps":2604.8660705831835,"mean_input_tokens":4096.0,"mean_output_tokens":4096.0,"ttft_p50_ms":1009.4648615049664,"ttft_p95_ms":3451.8876432455727,"ttft_p99_ms":3585.778701275411,"tpot_p50_ms":11.884123972524412,"tpot_p95_ms":12.538446310306478,"tpot_p99_ms":12.56025032742789,"e2e_p50_ms":49995.32897848985,"e2e_p95_ms":51952.65754524735,"e2e_p99_ms":52197.972133531,"itl_p50_ms":11.269403505139053,"itl_p95_ms":11.991078994469717,"itl_p99_ms":14.604782974638521,"validation_errors":[],"timestamp":"2026-07-17T15:02:55+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":4096,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c16_i4096_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c16_i4096_o4096_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":315.70741559399175,"request_tps":0.5067983585338531,"input_tps":2075.8460765546624,"output_tps":2075.8460765546624,"total_tps":4151.692153109325,"mean_input_tokens":4096.0,"mean_output_tokens":4096.0,"ttft_p50_ms":1260.2806405047886,"ttft_p95_ms":3616.4756425074274,"ttft_p99_ms":3780.7751082620234,"tpot_p50_ms":14.746094804759775,"tpot_p95_ms":16.07918718540703,"tpot_p99_ms":16.143852698078387,"e2e_p50_ms":61981.2938139803,"e2e_p95_ms":67067.79889845637,"e2e_p99_ms":68005.92907218699,"itl_p50_ms":14.284224511357024,"itl_p95_ms":15.910990411066448,"itl_p99_ms":45.711420371371794,"validation_errors":[],"timestamp":"2026-07-17T15:08:50+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":4096,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":59.382173,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c32_i4096_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c32_i4096_o4096_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":368.07704959000694,"request_tps":0.652037393440669,"input_tps":2670.7451635329803,"output_tps":2670.7451635329803,"total_tps":5341.490327065961,"mean_input_tokens":4096.0,"mean_output_tokens":4096.0,"ttft_p50_ms":1046.4716894930461,"ttft_p95_ms":6109.802595092333,"ttft_p99_ms":7507.865069422695,"tpot_p50_ms":17.224955683148647,"tpot_p95_ms":19.049794463059047,"tpot_p99_ms":19.610638235136754,"e2e_p50_ms":72142.15333499305,"e2e_p95_ms":80637.61701910844,"e2e_p99_ms":81378.1058801466,"itl_p50_ms":16.293261491227895,"itl_p95_ms":33.12414670654104,"itl_p99_ms":144.63371675577946,"validation_errors":[],"timestamp":"2026-07-17T15:15:39+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":4096,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":28.65815,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c48_i4096_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c48_i4096_o4096_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":51.84520575101487,"request_tps":1.5430549236162303,"input_tps":25281.411868528317,"output_tps":197.51103022287748,"total_tps":25478.922898751196,"mean_input_tokens":16384.0,"mean_output_tokens":128.0,"ttft_p50_ms":3391.746035005781,"ttft_p95_ms":7663.770186761393,"ttft_p99_ms":8197.932156920724,"tpot_p50_ms":57.28278776773299,"tpot_p95_ms":87.67777320484981,"tpot_p99_ms":90.1350372649365,"e2e_p50_ms":9970.18525149906,"e2e_p95_ms":13736.428562951915,"e2e_p99_ms":13753.886908720306,"itl_p50_ms":11.273295007413253,"itl_p95_ms":14.43824799644062,"itl_p99_ms":1384.4025468910675,"validation_errors":[],"timestamp":"2026-07-17T15:17:20+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":16384,"osl":128,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c16_i16384_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c16_i16384_o128_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":15.564335354982177,"request_tps":2.569978035534676,"input_tps":42106.52013420013,"output_tps":328.9571885484385,"total_tps":42435.47732274857,"mean_input_tokens":16384.0,"mean_output_tokens":128.0,"ttft_p50_ms":457.9559164994862,"ttft_p95_ms":2099.2526203932357,"ttft_p99_ms":2192.9485152018606,"tpot_p50_ms":13.598396586516404,"tpot_p95_ms":27.901264648416124,"tpot_p99_ms":28.692357144896015,"e2e_p50_ms":3450.0967814965406,"e2e_p95_ms":4068.7051240121946,"e2e_p99_ms":5086.153439160552,"itl_p50_ms":9.460874993237667,"itl_p95_ms":11.342074302956478,"itl_p99_ms":203.37754985695938,"validation_errors":[],"timestamp":"2026-07-17T15:18:15+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":16384,"osl":128,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c8_i16384_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c8_i16384_o128_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":31.556775627017487,"request_tps":2.535113249387482,"input_tps":41535.29547796451,"output_tps":648.9889918431954,"total_tps":42184.2844698077,"mean_input_tokens":16384.0,"mean_output_tokens":256.0,"ttft_p50_ms":858.6224889877485,"ttft_p95_ms":3671.8959908583192,"ttft_p99_ms":4287.6345709571615,"tpot_p50_ms":18.35497236860843,"tpot_p95_ms":29.25391153498055,"tpot_p99_ms":30.609352527336927,"e2e_p50_ms":5817.161843500799,"e2e_p95_ms":8460.579193865122,"e2e_p99_ms":8747.481106536288,"itl_p50_ms":11.29450899315998,"itl_p95_ms":13.361673073086422,"itl_p99_ms":153.6514054753931,"validation_errors":[],"timestamp":"2026-07-17T15:19:28+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":16384,"osl":256,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c16_i16384_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c16_i16384_o256_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":105.39911290601594,"request_tps":1.518039341969334,"input_tps":24871.55657882557,"output_tps":388.61807154414953,"total_tps":25260.17465036972,"mean_input_tokens":16384.0,"mean_output_tokens":256.0,"ttft_p50_ms":4344.6743239910575,"ttft_p95_ms":12384.403400536376,"ttft_p99_ms":14984.576612958625,"tpot_p50_ms":56.27194853327192,"tpot_p95_ms":131.3804475992675,"tpot_p99_ms":148.1926703065024,"e2e_p50_ms":20014.992970987805,"e2e_p95_ms":41420.064034486124,"e2e_p99_ms":41688.68667823961,"itl_p50_ms":14.380267501110211,"itl_p95_ms":16.16769310785457,"itl_p99_ms":394.61600778420745,"validation_errors":[],"timestamp":"2026-07-17T15:21:54+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":16384,"osl":256,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":-40.119466,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c32_i16384_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c32_i16384_o256_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":104.83551567498944,"request_tps":0.7631001715870375,"input_tps":12502.633211282022,"output_tps":390.7072878525632,"total_tps":12893.340499134585,"mean_input_tokens":16384.0,"mean_output_tokens":512.0,"ttft_p50_ms":3690.0039610045496,"ttft_p95_ms":12022.141144954365,"ttft_p99_ms":14146.387797934287,"tpot_p50_ms":33.318262476516885,"tpot_p95_ms":43.41690854653885,"tpot_p99_ms":48.539525781345304,"e2e_p50_ms":20784.491344486014,"e2e_p95_ms":28809.443283895962,"e2e_p99_ms":28821.795379848045,"itl_p50_ms":11.315565003314987,"itl_p95_ms":13.08837330288952,"itl_p99_ms":444.87671767099476,"validation_errors":[],"timestamp":"2026-07-17T15:24:24+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":16384,"osl":512,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c16_i16384_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c16_i16384_o512_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":33.26767950801877,"request_tps":1.2023682021572464,"input_tps":19699.600624144325,"output_tps":615.6125195045101,"total_tps":20315.213143648834,"mean_input_tokens":16384.0,"mean_output_tokens":512.0,"ttft_p50_ms":620.9158080018824,"ttft_p95_ms":2620.0735021935507,"ttft_p99_ms":3888.5656609461876,"tpot_p50_ms":9.843397334638578,"tpot_p95_ms":16.759823532081338,"tpot_p99_ms":16.98721003751879,"e2e_p50_ms":5771.793024483486,"e2e_p95_ms":9209.615290649526,"e2e_p99_ms":9229.382465930248,"itl_p50_ms":9.477565996348858,"itl_p95_ms":9.706762414134573,"itl_p99_ms":10.630374082538765,"validation_errors":[],"timestamp":"2026-07-17T15:25:40+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":16384,"osl":512,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c8_i16384_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c8_i16384_o512_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":70.62605009198887,"request_tps":1.1327265208206003,"input_tps":18558.591317124716,"output_tps":1159.9119573202947,"total_tps":19718.50327444501,"mean_input_tokens":16384.0,"mean_output_tokens":1024.0,"ttft_p50_ms":661.3422325026477,"ttft_p95_ms":2818.0315433564806,"ttft_p99_ms":4326.76606613968,"tpot_p50_ms":12.572099291799153,"tpot_p95_ms":15.81357289613904,"tpot_p99_ms":15.971525870842807,"e2e_p50_ms":13416.267475506174,"e2e_p95_ms":16975.908268145577,"e2e_p99_ms":17198.131637316837,"itl_p50_ms":11.383928504073992,"itl_p95_ms":11.993032388272697,"itl_p99_ms":13.703969563648572,"validation_errors":[],"timestamp":"2026-07-17T15:27:28+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":16384,"osl":1024,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c16_i16384_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c16_i16384_o1024_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":167.4178383500257,"request_tps":0.9556926643950748,"input_tps":15658.068613448906,"output_tps":978.6292883405566,"total_tps":16636.697901789463,"mean_input_tokens":16384.0,"mean_output_tokens":1024.0,"ttft_p50_ms":4372.533142508473,"ttft_p95_ms":9843.902905266437,"ttft_p99_ms":14281.949010449165,"tpot_p50_ms":28.940202102150092,"tpot_p95_ms":41.55440227066717,"tpot_p99_ms":45.706520427688616,"e2e_p50_ms":33765.42607201554,"e2e_p95_ms":48666.90775820455,"e2e_p99_ms":52279.75262388529,"itl_p50_ms":14.37780050036963,"itl_p95_ms":14.982720343687106,"itl_p99_ms":19.20701281342186,"validation_errors":[],"timestamp":"2026-07-17T15:31:00+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":16384,"osl":1024,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":-15.629003,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c32_i16384_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c32_i16384_o1024_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":194.13201279900386,"request_tps":0.41209071521258395,"input_tps":6751.694278042975,"output_tps":843.9617847553719,"total_tps":7595.656062798347,"mean_input_tokens":16384.0,"mean_output_tokens":2048.0,"ttft_p50_ms":2679.3966304830974,"ttft_p95_ms":12013.228289596735,"ttft_p99_ms":14137.788065448396,"tpot_p50_ms":16.726865833906423,"tpot_p95_ms":19.694048452005113,"tpot_p99_ms":20.62749142238333,"e2e_p50_ms":38262.84018950537,"e2e_p95_ms":46228.67684729281,"e2e_p99_ms":46236.33043784328,"itl_p50_ms":11.396950983908027,"itl_p95_ms":12.208413594635203,"itl_p99_ms":14.500913831871012,"validation_errors":[],"timestamp":"2026-07-17T15:35:01+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":16384,"osl":2048,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c16_i16384_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c16_i16384_o2048_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":111.03737742098747,"request_tps":0.36023905579419324,"input_tps":5902.156690132062,"output_tps":737.7695862665078,"total_tps":6639.92627639857,"mean_input_tokens":16384.0,"mean_output_tokens":2048.0,"ttft_p50_ms":806.1270774924196,"ttft_p95_ms":3890.919026949268,"ttft_p99_ms":4033.795104317833,"tpot_p50_ms":9.731363334148927,"tpot_p95_ms":10.6883619122362,"tpot_p99_ms":11.258486827995421,"e2e_p50_ms":21949.092091992497,"e2e_p95_ms":25405.39157645253,"e2e_p99_ms":25641.453124390682,"itl_p50_ms":9.478927488089539,"itl_p95_ms":9.939937671879306,"itl_p99_ms":11.202701253059788,"validation_errors":[],"timestamp":"2026-07-17T15:37:33+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":16384,"osl":2048,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c8_i16384_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c8_i16384_o2048_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":329.2878676429973,"request_tps":0.24294851970292838,"input_tps":15921.874187251115,"output_tps":31.097410521974833,"total_tps":15952.971597773088,"mean_input_tokens":65536.0,"mean_output_tokens":128.0,"ttft_p50_ms":25900.973087002058,"ttft_p95_ms":61443.24847861862,"ttft_p99_ms":68517.78760428191,"tpot_p50_ms":269.6728737992519,"tpot_p95_ms":728.2201385874883,"tpot_p99_ms":851.24265439658,"e2e_p50_ms":67964.12082201277,"e2e_p95_ms":121682.21357927832,"e2e_p99_ms":121703.39609344635,"itl_p50_ms":11.659070500172675,"itl_p95_ms":15.09003236715216,"itl_p99_ms":1257.250419750344,"validation_errors":[],"timestamp":"2026-07-17T15:43:53+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":65536,"osl":128,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c16_i65536_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c16_i65536_o128_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":171.11015289797797,"request_tps":0.23376754285205648,"input_tps":15320.189688352373,"output_tps":29.92224548506323,"total_tps":15350.111933837436,"mean_input_tokens":65536.0,"mean_output_tokens":128.0,"ttft_p50_ms":16781.179607496597,"ttft_p95_ms":33902.81918137189,"ttft_p99_ms":34018.54790562473,"tpot_p50_ms":105.79669053148841,"tpot_p95_ms":338.7818298902311,"tpot_p99_ms":400.2456677582447,"e2e_p50_ms":30042.90306850453,"e2e_p95_ms":60049.91058400483,"e2e_p99_ms":60062.70066564961,"itl_p50_ms":11.221178006962873,"itl_p95_ms":11.83725953742396,"itl_p99_ms":17.37415078474442,"validation_errors":[],"timestamp":"2026-07-17T15:47:31+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":65536,"osl":128,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c8_i65536_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c8_i65536_o128_a1.log"} +{"status":"COMPLETED","completed":5,"failed":0,"duration_s":47.589992579014506,"request_tps":0.1050641054776046,"input_tps":6885.481216580295,"output_tps":13.448205501133389,"total_tps":6898.929422081428,"mean_input_tokens":65536.0,"mean_output_tokens":128.0,"ttft_p50_ms":8509.552769974107,"ttft_p95_ms":8626.31096880068,"ttft_p99_ms":8640.830852958607,"tpot_p50_ms":7.826701417339849,"tpot_p95_ms":7.89419256391803,"tpot_p99_ms":7.907152459360878,"e2e_p50_ms":9514.172608993249,"e2e_p95_ms":9619.43628321169,"e2e_p99_ms":9633.783014251385,"itl_p50_ms":7.83353199949488,"itl_p95_ms":7.9304754064651215,"itl_p99_ms":7.983497839886694,"validation_errors":[],"timestamp":"2026-07-17T15:49:09+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":65536,"osl":128,"concurrency":1,"num_prompts":5,"warmup_requests":1,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/raw_outputs/sglang_adaptive_c1_i65536_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp4_dp2/logs/sglang_c1_i65536_o128_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":15.054012946988223,"request_tps":5.314197634990421,"input_tps":5441.738378230191,"output_tps":680.2172972787739,"total_tps":6121.955675508965,"mean_input_tokens":1024.0,"mean_output_tokens":128.0,"ttft_p50_ms":1382.0916779950494,"ttft_p95_ms":2053.2818755324115,"ttft_p99_ms":2057.0400498769595,"tpot_p50_ms":12.884241165354936,"tpot_p95_ms":17.38339773310288,"tpot_p99_ms":17.80342797728577,"e2e_p50_ms":2898.380812999676,"e2e_p95_ms":3478.1875671818852,"e2e_p99_ms":3482.381627372233,"itl_p50_ms":11.12091301183682,"itl_p95_ms":11.522537296696099,"itl_p99_ms":17.021936346718572,"validation_errors":[],"timestamp":"2026-07-17T16:08:04+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":128,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c16_i1024_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c16_i1024_o128_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":17.941262687993003,"request_tps":8.917989930947183,"input_tps":9132.021689289915,"output_tps":1141.5027111612394,"total_tps":10273.524400451155,"mean_input_tokens":1024.0,"mean_output_tokens":128.0,"ttft_p50_ms":1237.3634109972045,"ttft_p95_ms":2593.7202567671193,"ttft_p99_ms":2634.8118172440445,"tpot_p50_ms":13.61573586221161,"tpot_p95_ms":24.62699784652979,"tpot_p99_ms":26.75871241879217,"e2e_p50_ms":3877.538431494031,"e2e_p95_ms":4339.09629118134,"e2e_p99_ms":4342.917091700365,"itl_p50_ms":13.372761488426477,"itl_p95_ms":13.90225535724312,"itl_p99_ms":24.674699893803442,"validation_errors":[],"timestamp":"2026-07-17T16:09:13+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":128,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":67.81442,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c32_i1024_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c32_i1024_o128_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":20.647570365021238,"request_tps":11.62364364218759,"input_tps":11902.611089600092,"output_tps":1487.8263862000115,"total_tps":13390.437475800103,"mean_input_tokens":1024.0,"mean_output_tokens":128.0,"ttft_p50_ms":1223.56364649022,"ttft_p95_ms":3657.9823878593743,"ttft_p99_ms":3901.1024842015468,"tpot_p50_ms":15.864850570861156,"tpot_p95_ms":31.35466482988733,"tpot_p99_ms":36.165439743559176,"e2e_p50_ms":3232.93399400427,"e2e_p95_ms":5871.1645530493115,"e2e_p99_ms":5880.926621798135,"itl_p50_ms":15.319891987019219,"itl_p95_ms":16.04369879933074,"itl_p99_ms":33.49258425063453,"validation_errors":[],"timestamp":"2026-07-17T16:10:23+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":128,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":30.339277,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c48_i1024_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c48_i1024_o128_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":23.611792672018055,"request_tps":13.55254996708601,"input_tps":13877.811166296075,"output_tps":1734.7263957870093,"total_tps":15612.537562083084,"mean_input_tokens":1024.0,"mean_output_tokens":128.0,"ttft_p50_ms":1518.3321899967268,"ttft_p95_ms":4383.06237501093,"ttft_p99_ms":5198.992838273116,"tpot_p50_ms":18.304745960700156,"tpot_p95_ms":38.48727077279405,"tpot_p99_ms":48.80769688669293,"e2e_p50_ms":4001.3965599937364,"e2e_p95_ms":7424.4051037036115,"e2e_p99_ms":7439.646151844354,"itl_p50_ms":16.988425981253386,"itl_p95_ms":17.592736892402172,"itl_p99_ms":38.07221565832152,"validation_errors":[],"timestamp":"2026-07-17T16:11:24+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":128,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":16.594679,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c64_i1024_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c64_i1024_o128_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":17.228059102984844,"request_tps":4.643587505811355,"input_tps":4755.033605950827,"output_tps":1188.7584014877068,"total_tps":5943.792007438535,"mean_input_tokens":1024.0,"mean_output_tokens":256.0,"ttft_p50_ms":596.0867250105366,"ttft_p95_ms":640.4300157882972,"ttft_p99_ms":641.6279829625273,"tpot_p50_ms":11.085606190232177,"tpot_p95_ms":11.45201536900405,"tpot_p99_ms":11.629918239293985,"e2e_p50_ms":3422.157093984424,"e2e_p95_ms":3505.014261844917,"e2e_p99_ms":3507.766641480848,"itl_p50_ms":11.113315995316952,"itl_p95_ms":11.405721519258805,"itl_p99_ms":11.756163270038085,"validation_errors":[],"timestamp":"2026-07-17T16:12:29+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":256,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c16_i1024_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c16_i1024_o256_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":21.462638292025076,"request_tps":7.4548150988246205,"input_tps":7633.730661196411,"output_tps":1908.4326652991028,"total_tps":9542.163326495514,"mean_input_tokens":1024.0,"mean_output_tokens":256.0,"ttft_p50_ms":857.6523474912392,"ttft_p95_ms":875.2897063401178,"ttft_p99_ms":878.6032928308123,"tpot_p50_ms":13.316457576458523,"tpot_p95_ms":13.570595906697003,"tpot_p99_ms":14.447696668125559,"e2e_p50_ms":4260.504019490327,"e2e_p95_ms":4318.625815783162,"e2e_p99_ms":4327.296675649413,"itl_p50_ms":13.355390503420494,"itl_p95_ms":13.809860729088541,"itl_p99_ms":14.35637746064458,"validation_errors":[],"timestamp":"2026-07-17T16:13:34+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":256,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":60.539994,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c32_i1024_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c32_i1024_o256_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":25.579437770007644,"request_tps":9.382536166662911,"input_tps":9607.71703466282,"output_tps":2401.929258665705,"total_tps":12009.646293328526,"mean_input_tokens":1024.0,"mean_output_tokens":256.0,"ttft_p50_ms":1109.7394410026027,"ttft_p95_ms":1169.7603841719683,"ttft_p99_ms":1172.8214876246057,"tpot_p50_ms":15.566689378465526,"tpot_p95_ms":15.99623179624163,"tpot_p99_ms":17.57659248078205,"e2e_p50_ms":5082.730859008734,"e2e_p95_ms":5138.917709617817,"e2e_p99_ms":5146.753585859551,"itl_p50_ms":15.327452507335693,"itl_p95_ms":15.843623616092373,"itl_p99_ms":16.7054366561934,"validation_errors":[],"timestamp":"2026-07-17T16:14:39+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":256,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":25.858738,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c48_i1024_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c48_i1024_o256_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":29.31536271001096,"request_tps":10.915778295682577,"input_tps":11177.756974778958,"output_tps":2794.4392436947396,"total_tps":13972.196218473699,"mean_input_tokens":1024.0,"mean_output_tokens":256.0,"ttft_p50_ms":1411.2894629943185,"ttft_p95_ms":1535.2881631624768,"ttft_p99_ms":1540.5478561008931,"tpot_p50_ms":17.399233570562075,"tpot_p95_ms":20.299198804725666,"tpot_p99_ms":20.32316781586155,"e2e_p50_ms":5854.898385514389,"e2e_p95_ms":5966.888754944375,"e2e_p99_ms":5976.431857997086,"itl_p50_ms":16.985037000267766,"itl_p95_ms":17.55369435704779,"itl_p99_ms":19.30152166925834,"validation_errors":[],"timestamp":"2026-07-17T16:15:49+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":256,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":16.341447,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c64_i1024_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c64_i1024_o256_a1.log"} +{"status":"COMPLETED","completed":400,"failed":0,"duration_s":40.11911932498333,"request_tps":9.970308589274254,"input_tps":10209.595995416836,"output_tps":2552.398998854209,"total_tps":12761.994994271045,"mean_input_tokens":1024.0,"mean_output_tokens":256.0,"ttft_p50_ms":1648.2435400102986,"ttft_p95_ms":5374.191557338054,"ttft_p99_ms":6145.055652614683,"tpot_p50_ms":21.93098702946194,"tpot_p95_ms":35.831655043362204,"tpot_p99_ms":40.45455472284298,"e2e_p50_ms":7101.9430510059465,"e2e_p95_ms":11520.390641757695,"e2e_p99_ms":11536.21679575066,"itl_p50_ms":20.87863249471411,"itl_p95_ms":21.431169776769817,"itl_p99_ms":23.680255462531925,"validation_errors":[],"timestamp":"2026-07-17T16:17:09+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":256,"concurrency":80,"num_prompts":400,"warmup_requests":80,"attempt":1,"gain_pct":-8.661496,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c80_i1024_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c80_i1024_o256_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":31.320877724007005,"request_tps":2.5542068362497115,"input_tps":2615.5078003197045,"output_tps":1307.7539001598523,"total_tps":3923.261700479557,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":570.0232914969092,"ttft_p95_ms":633.3149687605328,"ttft_p99_ms":634.9983307984076,"tpot_p50_ms":11.087113134069742,"tpot_p95_ms":11.210613068668883,"tpot_p99_ms":11.460674748656434,"e2e_p50_ms":6245.348832002492,"e2e_p95_ms":6293.422394852678,"e2e_p99_ms":6294.212663613725,"itl_p50_ms":11.100818010163493,"itl_p95_ms":11.386717400455382,"itl_p99_ms":11.680330613453407,"validation_errors":[],"timestamp":"2026-07-17T16:18:16+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":512,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c16_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c16_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":38.667687139997724,"request_tps":4.137821830944126,"input_tps":4237.129554886785,"output_tps":2118.5647774433924,"total_tps":6355.694332330177,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":859.7180275100982,"ttft_p95_ms":908.7298117869068,"ttft_p99_ms":911.8328872596612,"tpot_p50_ms":13.336507234830133,"tpot_p95_ms":13.625917702349092,"tpot_p99_ms":13.947229752828639,"e2e_p50_ms":7718.824070485425,"e2e_p95_ms":7816.748389802524,"e2e_p99_ms":7820.500417527801,"itl_p50_ms":13.384003003011458,"itl_p95_ms":13.826452342618722,"itl_p99_ms":14.18888135754969,"validation_errors":[],"timestamp":"2026-07-17T16:19:31+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":512,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":62.000265,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c32_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c32_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":45.21105558000272,"request_tps":5.30843610973229,"input_tps":5435.838576365865,"output_tps":2717.9192881829326,"total_tps":8153.757864548797,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":1063.026758522028,"ttft_p95_ms":1150.1866941966,"ttft_p99_ms":1151.6954904500744,"tpot_p50_ms":15.455436555749815,"tpot_p95_ms":15.876636327278627,"tpot_p99_ms":16.407548489581373,"e2e_p50_ms":8981.335154996486,"e2e_p95_ms":9155.951357405866,"e2e_p99_ms":9163.289903351397,"itl_p50_ms":15.345362000516616,"itl_p95_ms":15.877072550938465,"itl_p99_ms":16.401249515765812,"validation_errors":[],"timestamp":"2026-07-17T16:20:52+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":512,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":28.290592,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c48_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c48_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":51.363041529024485,"request_tps":6.23016064613644,"input_tps":6379.684501643715,"output_tps":3189.8422508218573,"total_tps":9569.526752465572,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":1415.7074329996249,"ttft_p95_ms":1789.3682886482566,"ttft_p99_ms":1801.4290252685896,"tpot_p50_ms":17.239220581236598,"tpot_p95_ms":18.02802128821986,"tpot_p99_ms":18.713314402755646,"e2e_p50_ms":10166.021413489943,"e2e_p95_ms":10594.911860948196,"e2e_p99_ms":10603.709787309053,"itl_p50_ms":17.03167900268454,"itl_p95_ms":17.76110575447092,"itl_p99_ms":18.494471053418238,"validation_errors":[],"timestamp":"2026-07-17T16:22:22+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":512,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":17.363391,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c64_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c64_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":400,"failed":0,"duration_s":62.59106919000624,"request_tps":6.390688083402592,"input_tps":6544.0645974042545,"output_tps":3272.0322987021273,"total_tps":9816.09689610638,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":1636.5111249906477,"ttft_p95_ms":1735.7902167495922,"ttft_p99_ms":1741.941842274391,"tpot_p50_ms":21.342341816049373,"tpot_p95_ms":22.269109556859917,"tpot_p99_ms":23.146238388877986,"e2e_p50_ms":12435.423746996094,"e2e_p95_ms":12633.344333444256,"e2e_p99_ms":12641.628729277581,"itl_p50_ms":20.938980000209995,"itl_p95_ms":21.54475629067747,"itl_p99_ms":22.540847294149,"validation_errors":[],"timestamp":"2026-07-17T16:24:04+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":512,"concurrency":80,"num_prompts":400,"warmup_requests":80,"attempt":1,"gain_pct":2.576618,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c80_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c80_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":480,"failed":0,"duration_s":72.37176220299443,"request_tps":6.632421062978341,"input_tps":6791.599168489821,"output_tps":3395.7995842449104,"total_tps":10187.39875273473,"mean_input_tokens":1024.0,"mean_output_tokens":512.0,"ttft_p50_ms":1828.4241200017277,"ttft_p95_ms":5401.784680115816,"ttft_p99_ms":6436.750706877501,"tpot_p50_ms":22.96035002739125,"tpot_p95_ms":31.854171363216867,"tpot_p99_ms":32.979549741602106,"e2e_p50_ms":13552.070057485253,"e2e_p95_ms":18014.85111615766,"e2e_p99_ms":18025.249789118534,"itl_p50_ms":22.39036299579311,"itl_p95_ms":23.152189768734388,"itl_p99_ms":24.334271880506996,"validation_errors":[],"timestamp":"2026-07-17T16:25:57+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":512,"concurrency":96,"num_prompts":480,"warmup_requests":96,"attempt":1,"gain_pct":3.782581,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c96_i1024_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c96_i1024_o512_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":59.80518889398081,"request_tps":1.3376765708711227,"input_tps":1369.7808085720296,"output_tps":1369.7808085720296,"total_tps":2739.5616171440593,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":563.3855600026436,"ttft_p95_ms":596.1760190999485,"ttft_p99_ms":597.3192221322097,"tpot_p50_ms":11.098415154450162,"tpot_p95_ms":11.228709651909693,"tpot_p99_ms":11.315487031758883,"e2e_p50_ms":11884.609068511054,"e2e_p95_ms":12059.235532709863,"e2e_p99_ms":12062.951610588061,"itl_p50_ms":11.123113494249992,"itl_p95_ms":11.446965846698731,"itl_p99_ms":11.779220222088043,"validation_errors":[],"timestamp":"2026-07-17T16:27:32+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":1024,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c16_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c16_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":73.247655751009,"request_tps":2.184370248569982,"input_tps":2236.7951345356614,"output_tps":2236.7951345356614,"total_tps":4473.590269071323,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":863.6152764956933,"ttft_p95_ms":881.3651652351836,"ttft_p99_ms":885.4662714581355,"tpot_p50_ms":13.461573788871053,"tpot_p95_ms":13.636263585523968,"tpot_p99_ms":13.785426403018421,"e2e_p50_ms":14635.712293515098,"e2e_p95_ms":14794.735576839594,"e2e_p99_ms":14797.97805940354,"itl_p50_ms":13.455663007334806,"itl_p95_ms":13.938235052046366,"itl_p99_ms":14.541528454574289,"validation_errors":[],"timestamp":"2026-07-17T16:29:22+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":1024,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":63.295844,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c32_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c32_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":85.13150273700012,"request_tps":2.819167902409063,"input_tps":2886.8279320668803,"output_tps":2886.8279320668803,"total_tps":5773.655864133761,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":1096.915625501424,"ttft_p95_ms":1197.0535720480257,"ttft_p99_ms":1200.4239746421808,"tpot_p50_ms":15.495264083095272,"tpot_p95_ms":15.806569372279773,"tpot_p99_ms":15.975041794495912,"e2e_p50_ms":17005.225911023444,"e2e_p95_ms":17221.487269985664,"e2e_p99_ms":17226.83616282069,"itl_p50_ms":15.395562993944623,"itl_p95_ms":16.493364553025458,"itl_p99_ms":17.57684022741159,"validation_errors":[],"timestamp":"2026-07-17T16:31:28+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":1024,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":29.0609,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c48_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c48_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":95.11668399799964,"request_tps":3.3642888560615694,"input_tps":3445.031788607047,"output_tps":3445.031788607047,"total_tps":6890.063577214094,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":1417.2305965039413,"ttft_p95_ms":1585.1058885033126,"ttft_p99_ms":1592.2268711426295,"tpot_p50_ms":17.199984511229317,"tpot_p95_ms":17.782335471838007,"tpot_p99_ms":17.811198684222525,"e2e_p50_ms":19064.482695495826,"e2e_p95_ms":19261.028372829605,"e2e_p99_ms":19266.15519368759,"itl_p50_ms":16.99876350176055,"itl_p95_ms":18.663149206258822,"itl_p99_ms":20.05641621275571,"validation_errors":[],"timestamp":"2026-07-17T16:33:42+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":1024,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":19.336236,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c64_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c64_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":400,"failed":0,"duration_s":116.81321226101136,"request_tps":3.42427018534707,"input_tps":3506.4526697953997,"output_tps":3506.4526697953997,"total_tps":7012.9053395907995,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":1635.0847000139765,"ttft_p95_ms":1783.1740975132561,"ttft_p99_ms":1799.8248195223277,"tpot_p50_ms":21.362732011233213,"tpot_p95_ms":21.832199408118267,"tpot_p99_ms":22.022924048731134,"e2e_p50_ms":23253.83291799517,"e2e_p95_ms":23595.89082540915,"e2e_p99_ms":23599.32307598967,"itl_p50_ms":20.987878000596538,"itl_p95_ms":22.03347529139137,"itl_p99_ms":23.528212812379934,"validation_errors":[],"timestamp":"2026-07-17T16:36:19+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":1024,"concurrency":80,"num_prompts":400,"warmup_requests":80,"attempt":1,"gain_pct":1.782883,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c80_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c80_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":480,"failed":0,"duration_s":125.9527002729883,"request_tps":3.8109544214586433,"input_tps":3902.4173275736507,"output_tps":3902.4173275736507,"total_tps":7804.834655147301,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":1730.220769008156,"ttft_p95_ms":2066.845616349019,"ttft_p99_ms":2073.1713399491855,"tpot_p50_ms":22.914470147600607,"tpot_p95_ms":23.57522880361125,"tpot_p99_ms":23.771360357220193,"e2e_p50_ms":25164.00534499553,"e2e_p95_ms":25252.424278437684,"e2e_p99_ms":25255.959799495467,"itl_p50_ms":22.451310491305776,"itl_p95_ms":23.83248303522123,"itl_p99_ms":25.41624564502854,"validation_errors":[],"timestamp":"2026-07-17T16:39:13+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":1024,"concurrency":96,"num_prompts":480,"warmup_requests":96,"attempt":1,"gain_pct":11.292457,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c96_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c96_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":560,"failed":0,"duration_s":138.93999127100687,"request_tps":4.030517023048477,"input_tps":4127.24943160164,"output_tps":4127.24943160164,"total_tps":8254.49886320328,"mean_input_tokens":1024.0,"mean_output_tokens":1024.0,"ttft_p50_ms":1862.435032511712,"ttft_p95_ms":5406.920639138843,"ttft_p99_ms":6996.734152878053,"tpot_p50_ms":24.453566847029958,"tpot_p95_ms":29.4942103415268,"tpot_p99_ms":29.50636737118868,"e2e_p50_ms":26774.949187980383,"e2e_p95_ms":31470.473613250942,"e2e_p99_ms":31480.47503326554,"itl_p50_ms":23.773042499669828,"itl_p95_ms":25.805529502395075,"itl_p99_ms":28.501359703077437,"validation_errors":[],"timestamp":"2026-07-17T16:42:16+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":1024,"concurrency":112,"num_prompts":560,"warmup_requests":112,"attempt":1,"gain_pct":5.761355,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c112_i1024_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c112_i1024_o1024_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":117.04357979199267,"request_tps":0.6835060935608281,"input_tps":699.910239806288,"output_tps":1399.820479612576,"total_tps":2099.7307194188643,"mean_input_tokens":1024.0,"mean_output_tokens":2048.0,"ttft_p50_ms":506.9422090018634,"ttft_p95_ms":585.1958471932448,"ttft_p99_ms":585.8826018401305,"tpot_p50_ms":11.158849879085624,"tpot_p95_ms":11.275988920110583,"tpot_p99_ms":11.290578881376906,"e2e_p50_ms":23367.59526201058,"e2e_p95_ms":23590.09325500083,"e2e_p99_ms":23594.55572377279,"itl_p50_ms":11.163637522258796,"itl_p95_ms":11.596183900837786,"itl_p99_ms":12.135428480978591,"validation_errors":[],"timestamp":"2026-07-17T16:44:52+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":2048,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c16_i1024_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c16_i1024_o2048_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":142.3584418639948,"request_tps":1.1239235124030047,"input_tps":1150.8976767006768,"output_tps":2301.7953534013536,"total_tps":3452.6930301020307,"mean_input_tokens":1024.0,"mean_output_tokens":2048.0,"ttft_p50_ms":869.8576184979174,"ttft_p95_ms":918.320836215571,"ttft_p99_ms":921.4307083116728,"tpot_p50_ms":13.482959827066797,"tpot_p95_ms":13.69373979609596,"tpot_p99_ms":13.695822651369634,"e2e_p50_ms":28461.275758003467,"e2e_p95_ms":28943.203946345602,"e2e_p99_ms":28945.691601824656,"itl_p50_ms":13.438849491649307,"itl_p95_ms":14.342434455465991,"itl_p99_ms":15.000400209682994,"validation_errors":[],"timestamp":"2026-07-17T16:48:03+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":2048,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":64.435039,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c32_i1024_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c32_i1024_o2048_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":165.22273078098078,"request_tps":1.4525846344843674,"input_tps":1487.4466657119922,"output_tps":2974.8933314239844,"total_tps":4462.339997135977,"mean_input_tokens":1024.0,"mean_output_tokens":2048.0,"ttft_p50_ms":1208.249054994667,"ttft_p95_ms":1495.8067561063217,"ttft_p99_ms":1498.5044090848533,"tpot_p50_ms":15.552284777726118,"tpot_p95_ms":15.711430038328501,"tpot_p99_ms":15.851493504931986,"e2e_p50_ms":33027.427937980974,"e2e_p95_ms":33373.79980359692,"e2e_p99_ms":33380.66362451209,"itl_p50_ms":15.435137509484775,"itl_p95_ms":16.559038369450718,"itl_p99_ms":17.646082360006407,"validation_errors":[],"timestamp":"2026-07-17T16:51:39+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":2048,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":29.242303,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c48_i1024_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c48_i1024_o2048_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":183.0495341339847,"request_tps":1.7481606905689975,"input_tps":1790.1165471426534,"output_tps":3580.233094285307,"total_tps":5370.349641427961,"mean_input_tokens":1024.0,"mean_output_tokens":2048.0,"ttft_p50_ms":1361.9299690035405,"ttft_p95_ms":1549.7243121557403,"ttft_p99_ms":1555.0811735284515,"tpot_p50_ms":17.17630900782491,"tpot_p95_ms":17.535110065463094,"tpot_p99_ms":17.539916095493,"e2e_p50_ms":36536.3951909967,"e2e_p95_ms":37172.59425268276,"e2e_p99_ms":37178.44201388274,"itl_p50_ms":17.010341500281356,"itl_p95_ms":18.545709167665333,"itl_p99_ms":20.223750307923183,"validation_errors":[],"timestamp":"2026-07-17T16:55:21+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":2048,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":20.348285,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c64_i1024_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c64_i1024_o2048_a1.log"} +{"status":"COMPLETED","completed":400,"failed":0,"duration_s":224.81905570600065,"request_tps":1.7792086117605892,"input_tps":1821.9096184428433,"output_tps":3643.8192368856867,"total_tps":5465.72885532853,"mean_input_tokens":1024.0,"mean_output_tokens":2048.0,"ttft_p50_ms":1583.2390309951734,"ttft_p95_ms":1697.0053225100855,"ttft_p99_ms":1775.1434196103946,"tpot_p50_ms":21.19440216804748,"tpot_p95_ms":21.649373732711826,"tpot_p99_ms":21.656898619383533,"e2e_p50_ms":44870.99890199897,"e2e_p95_ms":45438.92366620421,"e2e_p99_ms":45453.030204990064,"itl_p50_ms":21.03363099740818,"itl_p95_ms":22.041975407046262,"itl_p99_ms":23.96549998869887,"validation_errors":[],"timestamp":"2026-07-17T16:59:57+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":2048,"concurrency":80,"num_prompts":400,"warmup_requests":80,"attempt":1,"gain_pct":1.776034,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c80_i1024_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c80_i1024_o2048_a1.log"} +{"status":"COMPLETED","completed":480,"failed":0,"duration_s":242.1225054159877,"request_tps":1.9824675082364522,"input_tps":2030.046728434127,"output_tps":4060.093456868254,"total_tps":6090.140185302381,"mean_input_tokens":1024.0,"mean_output_tokens":2048.0,"ttft_p50_ms":1843.10310849105,"ttft_p95_ms":2784.5976266398793,"ttft_p99_ms":2787.6198715806822,"tpot_p50_ms":22.68978495603186,"tpot_p95_ms":23.19058269598792,"tpot_p99_ms":23.39118022027744,"e2e_p50_ms":48176.34191949037,"e2e_p95_ms":49105.42208846455,"e2e_p99_ms":49110.17938124132,"itl_p50_ms":22.51145598711446,"itl_p95_ms":24.10398916108533,"itl_p99_ms":45.433270622161274,"validation_errors":[],"timestamp":"2026-07-17T17:04:51+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":2048,"concurrency":96,"num_prompts":480,"warmup_requests":96,"attempt":1,"gain_pct":11.424118,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c96_i1024_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c96_i1024_o2048_a1.log"} +{"status":"COMPLETED","completed":560,"failed":0,"duration_s":261.42519629898015,"request_tps":2.142104158007606,"input_tps":2193.5146577997884,"output_tps":4387.029315599577,"total_tps":6580.543973399365,"mean_input_tokens":1024.0,"mean_output_tokens":2048.0,"ttft_p50_ms":1990.0958810030716,"ttft_p95_ms":5214.152042598289,"ttft_p99_ms":5367.271140854864,"tpot_p50_ms":24.31250025061165,"tpot_p95_ms":25.96440309870904,"tpot_p99_ms":25.97778251536822,"e2e_p50_ms":51727.91999450419,"e2e_p95_ms":54434.7598772918,"e2e_p99_ms":54442.764464871434,"itl_p50_ms":23.778170987498015,"itl_p95_ms":32.0138564740774,"itl_p99_ms":97.92745111364654,"validation_errors":[],"timestamp":"2026-07-17T17:09:56+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":2048,"concurrency":112,"num_prompts":560,"warmup_requests":112,"attempt":1,"gain_pct":8.052422,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c112_i1024_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c112_i1024_o2048_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":231.29833343799692,"request_tps":0.3458736550795133,"input_tps":354.1746228014216,"output_tps":1416.6984912056864,"total_tps":1770.873114007108,"mean_input_tokens":1024.0,"mean_output_tokens":4096.0,"ttft_p50_ms":565.8210745023098,"ttft_p95_ms":662.0139731341624,"ttft_p99_ms":665.7764394569676,"tpot_p50_ms":11.14444260598332,"tpot_p95_ms":11.21662146521784,"tpot_p99_ms":11.224546077784668,"e2e_p50_ms":46243.83415050397,"e2e_p95_ms":46457.84056803823,"e2e_p99_ms":46459.05670498265,"itl_p50_ms":11.148804493132047,"itl_p95_ms":11.742163961753247,"itl_p99_ms":12.337002912827305,"validation_errors":[],"timestamp":"2026-07-17T17:14:32+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":4096,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c16_i1024_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c16_i1024_o4096_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":279.46171132999007,"request_tps":0.5725292357172717,"input_tps":586.2699373744862,"output_tps":2345.0797494979447,"total_tps":2931.3496868724305,"mean_input_tokens":1024.0,"mean_output_tokens":4096.0,"ttft_p50_ms":831.157909007743,"ttft_p95_ms":949.1389760994934,"ttft_p99_ms":950.8631416532444,"tpot_p50_ms":13.43476887765626,"tpot_p95_ms":13.631646927391118,"tpot_p99_ms":13.651461508853693,"e2e_p50_ms":55947.05397100188,"e2e_p95_ms":56701.55322876817,"e2e_p99_ms":56709.372358283144,"itl_p50_ms":13.383695477386937,"itl_p95_ms":14.629215201421173,"itl_p99_ms":47.957163318351654,"validation_errors":[],"timestamp":"2026-07-17T17:19:56+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":4096,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":65.531323,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c32_i1024_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c32_i1024_o4096_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":328.8155661879864,"request_tps":0.7298924524235879,"input_tps":747.409871281754,"output_tps":2989.639485127016,"total_tps":3737.04935640877,"mean_input_tokens":1024.0,"mean_output_tokens":4096.0,"ttft_p50_ms":1048.2123504916672,"ttft_p95_ms":1205.6771881951136,"ttft_p99_ms":1208.5599871628801,"tpot_p50_ms":15.827440055434321,"tpot_p95_ms":16.279111774915833,"tpot_p99_ms":16.416754268461386,"e2e_p50_ms":65888.75933398958,"e2e_p95_ms":67493.92831464647,"e2e_p99_ms":68296.89107587212,"itl_p50_ms":15.332058013882488,"itl_p95_ms":30.15040629688883,"itl_p99_ms":139.72497898445,"validation_errors":[],"timestamp":"2026-07-17T17:26:04+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":4096,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":27.485621,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c48_i1024_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c48_i1024_o4096_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":372.63833744399017,"request_tps":0.8587414869735404,"input_tps":879.3512826609053,"output_tps":3517.4051306436213,"total_tps":4396.756413304526,"mean_input_tokens":1024.0,"mean_output_tokens":4096.0,"ttft_p50_ms":1064.568991001579,"ttft_p95_ms":1484.240312478505,"ttft_p99_ms":1494.7647402083385,"tpot_p50_ms":17.70246480903244,"tpot_p95_ms":19.126231117326192,"tpot_p99_ms":19.430074082775413,"e2e_p50_ms":73622.7421079966,"e2e_p95_ms":79347.52537073218,"e2e_p99_ms":80886.26518901758,"itl_p50_ms":16.57277249614708,"itl_p95_ms":67.37879445863655,"itl_p99_ms":188.79961527796695,"validation_errors":[],"timestamp":"2026-07-17T17:33:03+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":4096,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":17.653153,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c64_i1024_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c64_i1024_o4096_a1.log"} +{"status":"COMPLETED","completed":400,"failed":0,"duration_s":453.97070015801,"request_tps":0.8811141332706608,"input_tps":902.2608724691567,"output_tps":3609.0434898766266,"total_tps":4511.304362345783,"mean_input_tokens":1024.0,"mean_output_tokens":4096.0,"ttft_p50_ms":1353.5852509958204,"ttft_p95_ms":2471.20405595051,"ttft_p99_ms":2852.0741208767868,"tpot_p50_ms":21.771030179120434,"tpot_p95_ms":22.25056600771442,"tpot_p99_ms":22.435508144002945,"e2e_p50_ms":90666.26933802036,"e2e_p95_ms":92594.76635410829,"e2e_p99_ms":93538.52583563421,"itl_p50_ms":20.70259500760585,"itl_p95_ms":63.72486050531734,"itl_p99_ms":233.46285211038776,"validation_errors":[],"timestamp":"2026-07-17T17:41:18+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":4096,"concurrency":80,"num_prompts":400,"warmup_requests":80,"attempt":1,"gain_pct":2.605283,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c80_i1024_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c80_i1024_o4096_a1.log"} +{"status":"COMPLETED","completed":480,"failed":0,"duration_s":488.67755048998515,"request_tps":0.9822427887647297,"input_tps":1005.8166156950832,"output_tps":4023.266462780333,"total_tps":5029.083078475416,"mean_input_tokens":1024.0,"mean_output_tokens":4096.0,"ttft_p50_ms":1433.890396481729,"ttft_p95_ms":3511.4277350599873,"ttft_p99_ms":3573.8617950794282,"tpot_p50_ms":23.315685800365817,"tpot_p95_ms":23.887768479282155,"tpot_p99_ms":24.112616446222003,"e2e_p50_ms":97320.47356250405,"e2e_p95_ms":99323.78093458246,"e2e_p99_ms":100206.5333346359,"itl_p50_ms":22.250667010666803,"itl_p95_ms":60.40554633800619,"itl_p99_ms":202.92183973884676,"validation_errors":[],"timestamp":"2026-07-17T17:50:10+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":4096,"concurrency":96,"num_prompts":480,"warmup_requests":96,"attempt":1,"gain_pct":11.477362,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c96_i1024_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c96_i1024_o4096_a1.log"} +{"status":"COMPLETED","completed":560,"failed":0,"duration_s":537.560737177002,"request_tps":1.0417427488116742,"input_tps":1066.7445747831543,"output_tps":4266.978299132617,"total_tps":5333.722873915772,"mean_input_tokens":1024.0,"mean_output_tokens":4096.0,"ttft_p50_ms":1469.2450400034431,"ttft_p95_ms":4217.376757388409,"ttft_p99_ms":4708.559102280415,"tpot_p50_ms":25.68550720134359,"tpot_p95_ms":26.779137850637856,"tpot_p99_ms":27.122215110817848,"e2e_p50_ms":107385.05934149725,"e2e_p95_ms":111276.97451022104,"e2e_p99_ms":112824.55985818262,"itl_p50_ms":22.98143297957722,"itl_p95_ms":100.123521126806,"itl_p99_ms":239.84584212885233,"validation_errors":[],"timestamp":"2026-07-17T17:59:52+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":4096,"concurrency":112,"num_prompts":560,"warmup_requests":112,"attempt":1,"gain_pct":6.057561,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c112_i1024_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c112_i1024_o4096_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":18.692009602993494,"request_tps":4.279903643275902,"input_tps":17530.485322858094,"output_tps":547.8276663393154,"total_tps":18078.31298919741,"mean_input_tokens":4096.0,"mean_output_tokens":128.0,"ttft_p50_ms":1951.9326144945808,"ttft_p95_ms":2854.8029153593234,"ttft_p99_ms":2857.5591351633193,"tpot_p50_ms":13.231814413388282,"tpot_p95_ms":23.37103073154512,"tpot_p99_ms":24.778366846160285,"e2e_p50_ms":3598.2393074955326,"e2e_p95_ms":4313.876258886012,"e2e_p99_ms":4318.468388114998,"itl_p50_ms":11.169903009431437,"itl_p95_ms":11.511199056985788,"itl_p99_ms":23.050503027625375,"validation_errors":[],"timestamp":"2026-07-17T18:00:46+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":4096,"osl":128,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c16_i4096_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c16_i4096_o128_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":21.074660281999968,"request_tps":7.592055950560553,"input_tps":31097.061173496026,"output_tps":971.7831616717508,"total_tps":32068.844335167778,"mean_input_tokens":4096.0,"mean_output_tokens":128.0,"ttft_p50_ms":1443.4768985083792,"ttft_p95_ms":3953.711952790036,"ttft_p99_ms":4150.659612781601,"tpot_p50_ms":14.812531889857189,"tpot_p95_ms":33.77201899813486,"tpot_p99_ms":37.18889905785816,"e2e_p50_ms":3962.458190508187,"e2e_p95_ms":5886.929638324364,"e2e_p99_ms":5891.448071665363,"itl_p50_ms":13.44492650241591,"itl_p95_ms":13.903244183165953,"itl_p99_ms":32.96290160709777,"validation_errors":[],"timestamp":"2026-07-17T18:01:50+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":4096,"osl":128,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":77.388478,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c32_i4096_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c32_i4096_o128_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":41.610279315995285,"request_tps":5.767805550580438,"input_tps":23624.931535177475,"output_tps":738.2791104742961,"total_tps":24363.21064565177,"mean_input_tokens":4096.0,"mean_output_tokens":128.0,"ttft_p50_ms":1436.889581993455,"ttft_p95_ms":12707.814035916817,"ttft_p99_ms":15677.366074182493,"tpot_p50_ms":18.694978846488226,"tpot_p95_ms":103.98695107520096,"tpot_p99_ms":127.99820311829727,"e2e_p50_ms":3533.2962609973038,"e2e_p95_ms":17935.042509211053,"e2e_p99_ms":17945.102309090144,"itl_p50_ms":15.439160997630097,"itl_p95_ms":15.97879121109145,"itl_p99_ms":38.963907721336,"validation_errors":[],"timestamp":"2026-07-17T18:03:08+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":4096,"osl":128,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":-24.028411,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c48_i4096_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c48_i4096_o128_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":17.6506106450106,"request_tps":4.532421093465911,"input_tps":18564.79679883637,"output_tps":1160.2997999272732,"total_tps":19725.096598763645,"mean_input_tokens":4096.0,"mean_output_tokens":256.0,"ttft_p50_ms":665.3127190074883,"ttft_p95_ms":704.0575098872068,"ttft_p99_ms":705.1499696262181,"tpot_p50_ms":11.223498725460148,"tpot_p95_ms":11.675384529157514,"tpot_p99_ms":11.84122688031422,"e2e_p50_ms":3538.037299993448,"e2e_p95_ms":3576.097404587199,"e2e_p99_ms":3578.863082959142,"itl_p50_ms":11.20034500490874,"itl_p95_ms":11.517339404963423,"itl_p99_ms":12.013422485906627,"validation_errors":[],"timestamp":"2026-07-17T18:04:13+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":4096,"osl":256,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c16_i4096_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c16_i4096_o256_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":22.741501308017178,"request_tps":7.035595312416528,"input_tps":28817.7983996581,"output_tps":1801.1123999786312,"total_tps":30618.91079963673,"mean_input_tokens":4096.0,"mean_output_tokens":256.0,"ttft_p50_ms":949.2147215059958,"ttft_p95_ms":1509.1511025384534,"ttft_p99_ms":1512.9880306427367,"tpot_p50_ms":13.57577133920345,"tpot_p95_ms":15.37578445390168,"tpot_p99_ms":16.44130728449604,"e2e_p50_ms":4446.69276298373,"e2e_p95_ms":4944.949197085225,"e2e_p99_ms":4948.263438291324,"itl_p50_ms":13.440024995361455,"itl_p95_ms":13.856044771091547,"itl_p99_ms":14.429115046223162,"validation_errors":[],"timestamp":"2026-07-17T18:05:17+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":4096,"osl":256,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":55.228192,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c32_i4096_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c32_i4096_o256_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":26.991804453980876,"request_tps":8.891587830268373,"input_tps":36419.943752779254,"output_tps":2276.2464845487034,"total_tps":38696.19023732795,"mean_input_tokens":4096.0,"mean_output_tokens":256.0,"ttft_p50_ms":1301.0679170110961,"ttft_p95_ms":1475.3141506938846,"ttft_p99_ms":1480.5723488260992,"tpot_p50_ms":15.65468922153563,"tpot_p95_ms":17.40524464791901,"tpot_p99_ms":18.709869167998015,"e2e_p50_ms":5389.691296004457,"e2e_p95_ms":5455.543053014844,"e2e_p99_ms":5463.990145312564,"itl_p50_ms":15.439089998835698,"itl_p95_ms":15.92151074873982,"itl_p99_ms":17.994337023992596,"validation_errors":[],"timestamp":"2026-07-17T18:06:27+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":4096,"osl":256,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":26.380035,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c48_i4096_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c48_i4096_o256_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":55.12290118000237,"request_tps":5.805209688710841,"input_tps":23778.138884959604,"output_tps":1486.1336803099753,"total_tps":25264.272565269577,"mean_input_tokens":4096.0,"mean_output_tokens":256.0,"ttft_p50_ms":1546.5141180029605,"ttft_p95_ms":16799.997200894002,"ttft_p99_ms":21152.33498007874,"tpot_p50_ms":19.521068156852074,"tpot_p95_ms":74.8253733152695,"tpot_p99_ms":93.15472479592141,"e2e_p50_ms":6007.05336399551,"e2e_p95_ms":25902.040548097284,"e2e_p99_ms":25913.455488623003,"itl_p50_ms":17.012712996802293,"itl_p95_ms":17.57845066604205,"itl_p99_ms":18.72491677204375,"validation_errors":[],"timestamp":"2026-07-17T18:08:07+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":4096,"osl":256,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":-34.711215,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c64_i4096_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c64_i4096_o256_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":32.03290575300343,"request_tps":2.4974318788578564,"input_tps":10229.48097580178,"output_tps":1278.6851219752225,"total_tps":11508.166097777003,"mean_input_tokens":4096.0,"mean_output_tokens":512.0,"ttft_p50_ms":628.6495430103969,"ttft_p95_ms":810.780344788509,"ttft_p99_ms":812.6056499377592,"tpot_p50_ms":11.239742394337393,"tpot_p95_ms":11.378759735886627,"tpot_p99_ms":11.581611429780144,"e2e_p50_ms":6377.996978000738,"e2e_p95_ms":6497.331574848795,"e2e_p99_ms":6500.207945857255,"itl_p50_ms":11.209970005438663,"itl_p95_ms":11.509585742896887,"itl_p99_ms":11.831996945256831,"validation_errors":[],"timestamp":"2026-07-17T18:09:18+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":4096,"osl":512,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c16_i4096_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c16_i4096_o512_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":39.65205314499326,"request_tps":4.035100008943741,"input_tps":16527.769636633562,"output_tps":2065.9712045791953,"total_tps":18593.74084121276,"mean_input_tokens":4096.0,"mean_output_tokens":512.0,"ttft_p50_ms":979.1853799979435,"ttft_p95_ms":1026.2283552918234,"ttft_p99_ms":1029.8960930790054,"tpot_p50_ms":13.536027822882271,"tpot_p95_ms":13.714120765160265,"tpot_p99_ms":14.42542356156098,"e2e_p50_ms":7910.203532504966,"e2e_p95_ms":7955.969148920849,"e2e_p99_ms":7961.606507452379,"itl_p50_ms":13.440052513033152,"itl_p95_ms":13.856934497016482,"itl_p99_ms":14.24744133197237,"validation_errors":[],"timestamp":"2026-07-17T18:10:47+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":4096,"osl":512,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":61.569973,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c32_i4096_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c32_i4096_o512_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":50.257221851992654,"request_tps":4.775433085155387,"input_tps":19560.173916796466,"output_tps":2445.0217395995583,"total_tps":22005.195656396023,"mean_input_tokens":4096.0,"mean_output_tokens":512.0,"ttft_p50_ms":1334.372033001273,"ttft_p95_ms":3672.946003654215,"ttft_p99_ms":3730.162444123125,"tpot_p50_ms":15.647803050845885,"tpot_p95_ms":20.085243091832755,"tpot_p99_ms":20.09141453025749,"e2e_p50_ms":9347.90538350353,"e2e_p95_ms":11602.971243044885,"e2e_p99_ms":11607.989926116134,"itl_p50_ms":15.398803501739167,"itl_p95_ms":15.830107554211281,"itl_p99_ms":16.431875858979765,"validation_errors":[],"timestamp":"2026-07-17T18:12:18+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":4096,"osl":512,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":18.347329,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c48_i4096_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c48_i4096_o512_a1.log"} +{"status":"COMPLETED","completed":320,"failed":0,"duration_s":71.73325796701829,"request_tps":4.460971229650973,"input_tps":18272.138156650384,"output_tps":2284.017269581298,"total_tps":20556.155426231682,"mean_input_tokens":4096.0,"mean_output_tokens":512.0,"ttft_p50_ms":1571.310530998744,"ttft_p95_ms":15770.35549840075,"ttft_p99_ms":16155.86201698461,"tpot_p50_ms":18.148766381618447,"tpot_p95_ms":36.543274513151815,"tpot_p99_ms":45.34557027561094,"e2e_p50_ms":10405.667708997498,"e2e_p95_ms":25268.520599155454,"e2e_p99_ms":25277.666622776887,"itl_p50_ms":16.98898000176996,"itl_p95_ms":17.59964034135919,"itl_p99_ms":18.23573372879764,"validation_errors":[],"timestamp":"2026-07-17T18:14:07+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":4096,"osl":512,"concurrency":64,"num_prompts":320,"warmup_requests":64,"attempt":1,"gain_pct":-6.584991,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c64_i4096_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c64_i4096_o512_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":84.17238956299843,"request_tps":0.9504304251707666,"input_tps":3892.96302149946,"output_tps":973.240755374865,"total_tps":4866.203776874325,"mean_input_tokens":4096.0,"mean_output_tokens":1024.0,"ttft_p50_ms":3412.0989450020716,"ttft_p95_ms":5341.084747290006,"ttft_p99_ms":5408.532623951905,"tpot_p50_ms":13.098844145154963,"tpot_p95_ms":15.612376401727092,"tpot_p99_ms":15.780222639921716,"e2e_p50_ms":16798.50147549587,"e2e_p95_ms":16996.13628389052,"e2e_p99_ms":16998.17297552043,"itl_p50_ms":11.183776499819942,"itl_p95_ms":11.503916363290045,"itl_p99_ms":11.80565070535522,"validation_errors":[],"timestamp":"2026-07-17T18:16:10+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":4096,"osl":1024,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c16_i4096_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c16_i4096_o1024_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":49.00617907100241,"request_tps":0.816223601967543,"input_tps":3343.251873659056,"output_tps":835.812968414764,"total_tps":4179.06484207382,"mean_input_tokens":4096.0,"mean_output_tokens":1024.0,"ttft_p50_ms":487.816484994255,"ttft_p95_ms":514.9793325908831,"ttft_p99_ms":517.2700856343727,"tpot_p50_ms":9.063061321607039,"tpot_p95_ms":9.168658600818265,"tpot_p99_ms":9.181731317627253,"e2e_p50_ms":9763.81581449823,"e2e_p95_ms":9865.12596210814,"e2e_p99_ms":9865.763635528856,"itl_p50_ms":9.079474504687823,"itl_p95_ms":9.356724565441253,"itl_p99_ms":9.64074601768516,"validation_errors":[],"timestamp":"2026-07-17T18:17:44+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":4096,"osl":1024,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c8_i4096_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c8_i4096_o1024_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":117.85771219502203,"request_tps":0.678784599752132,"input_tps":2780.3017205847327,"output_tps":1390.1508602923664,"total_tps":4170.4525808770995,"mean_input_tokens":4096.0,"mean_output_tokens":2048.0,"ttft_p50_ms":627.879199484596,"ttft_p95_ms":745.9339683467988,"ttft_p99_ms":781.2846753897611,"tpot_p50_ms":11.163639097704445,"tpot_p95_ms":11.289370684458182,"tpot_p99_ms":11.31765497079294,"e2e_p50_ms":23494.19227799808,"e2e_p95_ms":23841.624084988143,"e2e_p99_ms":23849.924933970033,"itl_p50_ms":11.178686982020736,"itl_p95_ms":11.659184737072792,"itl_p99_ms":12.22486957034562,"validation_errors":[],"timestamp":"2026-07-17T18:20:22+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":4096,"osl":2048,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c16_i4096_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c16_i4096_o2048_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":166.57742296200013,"request_tps":0.9605143191373504,"input_tps":3934.2666511865873,"output_tps":1967.1333255932936,"total_tps":5901.399976779881,"mean_input_tokens":4096.0,"mean_output_tokens":2048.0,"ttft_p50_ms":1437.6813385024434,"ttft_p95_ms":9997.93344304344,"ttft_p99_ms":10624.715033108077,"tpot_p50_ms":13.822166616515437,"tpot_p95_ms":17.514378524309723,"tpot_p99_ms":17.999018236277625,"e2e_p50_ms":33067.105534501025,"e2e_p95_ms":38051.43786944682,"e2e_p99_ms":38056.612262004055,"itl_p50_ms":13.408671497018076,"itl_p95_ms":14.20984975848114,"itl_p99_ms":14.84045732067898,"validation_errors":[],"timestamp":"2026-07-17T18:23:44+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":4096,"osl":2048,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":41.505025,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c32_i4096_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c32_i4096_o2048_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":232.17423882099683,"request_tps":0.3445688049037986,"input_tps":1411.353824885959,"output_tps":1411.353824885959,"total_tps":2822.707649771918,"mean_input_tokens":4096.0,"mean_output_tokens":4096.0,"ttft_p50_ms":658.2362344925059,"ttft_p95_ms":766.652323146991,"ttft_p99_ms":770.5815443859319,"tpot_p50_ms":11.1520613114772,"tpot_p95_ms":11.253938844869321,"tpot_p99_ms":11.279828577950143,"e2e_p50_ms":46386.5971865016,"e2e_p95_ms":46700.616775894014,"e2e_p99_ms":46707.719193845696,"itl_p50_ms":11.15739748638589,"itl_p95_ms":11.72539189865347,"itl_p99_ms":12.263577906996947,"validation_errors":[],"timestamp":"2026-07-17T18:28:13+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":4096,"osl":4096,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c16_i4096_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c16_i4096_o4096_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":279.56103853700915,"request_tps":0.5723258177795713,"input_tps":2344.246549625124,"output_tps":2344.246549625124,"total_tps":4688.493099250248,"mean_input_tokens":4096.0,"mean_output_tokens":4096.0,"ttft_p50_ms":955.9277034859406,"ttft_p95_ms":998.5283098896616,"ttft_p99_ms":1000.0105973641622,"tpot_p50_ms":13.378227836261525,"tpot_p95_ms":13.62592549874086,"tpot_p99_ms":13.6437818219077,"e2e_p50_ms":55684.981643993524,"e2e_p95_ms":56547.210149372404,"e2e_p99_ms":56567.611172156176,"itl_p50_ms":13.364801998250186,"itl_p95_ms":14.55830567574594,"itl_p99_ms":44.10593267501127,"validation_errors":[],"timestamp":"2026-07-17T18:33:32+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":4096,"osl":4096,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":66.099139,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c32_i4096_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c32_i4096_o4096_a1.log"} +{"status":"COMPLETED","completed":240,"failed":0,"duration_s":356.99578490600106,"request_tps":0.672276845126318,"input_tps":2753.6459576373986,"output_tps":2753.6459576373986,"total_tps":5507.291915274797,"mean_input_tokens":4096.0,"mean_output_tokens":4096.0,"ttft_p50_ms":1142.216414998984,"ttft_p95_ms":10983.74527424021,"ttft_p99_ms":13758.446350894805,"tpot_p50_ms":16.290446536387208,"tpot_p95_ms":18.585426933722715,"tpot_p99_ms":19.16210820672676,"e2e_p50_ms":68431.44404051418,"e2e_p95_ms":79332.27646894811,"e2e_p99_ms":80249.21937885287,"itl_p50_ms":15.221045992802829,"itl_p95_ms":30.714305711444467,"itl_p99_ms":142.2577843689942,"validation_errors":[],"timestamp":"2026-07-17T18:40:13+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":4096,"osl":4096,"concurrency":48,"num_prompts":240,"warmup_requests":48,"attempt":1,"gain_pct":17.464008,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c48_i4096_o4096_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c48_i4096_o4096_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":108.01222387200687,"request_tps":0.7406569102289663,"input_tps":12134.922817191384,"output_tps":94.80408450930769,"total_tps":12229.726901700691,"mean_input_tokens":16384.0,"mean_output_tokens":128.0,"ttft_p50_ms":10602.329202491092,"ttft_p95_ms":21405.395740288073,"ttft_p99_ms":22662.041889641834,"tpot_p50_ms":75.25741792119871,"tpot_p95_ms":161.3513646578814,"tpot_p99_ms":173.44305937297364,"e2e_p50_ms":23848.901544508408,"e2e_p95_ms":24846.690672510886,"e2e_p99_ms":24852.20741442259,"itl_p50_ms":11.28708450414706,"itl_p95_ms":11.559761120588519,"itl_p99_ms":21.634374935529184,"validation_errors":[],"timestamp":"2026-07-17T18:42:41+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":16384,"osl":128,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c16_i16384_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c16_i16384_o128_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":9.510352077981224,"request_tps":4.205943131444073,"input_tps":68910.17226557969,"output_tps":538.3607208248413,"total_tps":69448.53298640453,"mean_input_tokens":16384.0,"mean_output_tokens":128.0,"ttft_p50_ms":698.7149469932774,"ttft_p95_ms":763.2633192522917,"ttft_p99_ms":767.3603503999766,"tpot_p50_ms":9.303440322790582,"tpot_p95_ms":11.092404683357046,"tpot_p99_ms":11.116226501753701,"e2e_p50_ms":1880.761241001892,"e2e_p95_ms":1932.8732164023677,"e2e_p99_ms":1938.0927888207952,"itl_p50_ms":9.09235748986248,"itl_p95_ms":9.363576257601382,"itl_p99_ms":15.560581730678681,"validation_errors":[],"timestamp":"2026-07-17T18:43:35+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":16384,"osl":128,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c8_i16384_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c8_i16384_o128_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":19.80635820797761,"request_tps":4.039106995842253,"input_tps":66176.72901987948,"output_tps":1034.0113909356169,"total_tps":67210.7404108151,"mean_input_tokens":16384.0,"mean_output_tokens":256.0,"ttft_p50_ms":998.0732240073849,"ttft_p95_ms":1167.119920400728,"ttft_p99_ms":1171.1755860835547,"tpot_p50_ms":11.438905978495455,"tpot_p95_ms":12.638637241062836,"tpot_p99_ms":12.745974239305474,"e2e_p50_ms":3914.8015340033453,"e2e_p95_ms":4085.321819403907,"e2e_p99_ms":4091.2151140283095,"itl_p50_ms":11.321043493808247,"itl_p95_ms":11.669101359439082,"itl_p99_ms":13.695296847145048,"validation_errors":[],"timestamp":"2026-07-17T18:44:42+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":16384,"osl":256,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c16_i16384_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c16_i16384_o256_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":135.02388066001004,"request_tps":1.1849755703798783,"input_tps":19414.639745103927,"output_tps":303.35374601724885,"total_tps":19717.993491121175,"mean_input_tokens":16384.0,"mean_output_tokens":256.0,"ttft_p50_ms":2657.3630795028294,"ttft_p95_ms":38935.0217523868,"ttft_p99_ms":43482.15613469569,"tpot_p50_ms":37.42642922158006,"tpot_p95_ms":157.64979899670314,"tpot_p99_ms":175.63668355100796,"e2e_p50_ms":29046.720717000426,"e2e_p95_ms":47560.73000529723,"e2e_p99_ms":47568.55104122369,"itl_p50_ms":13.597245997516438,"itl_p95_ms":14.050246411352418,"itl_p99_ms":16.797334338189135,"validation_errors":[],"timestamp":"2026-07-17T18:47:45+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":16384,"osl":256,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":-70.662437,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c32_i16384_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c32_i16384_o256_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":137.79956430502352,"request_tps":0.5805533595368819,"input_tps":9511.786242652273,"output_tps":297.24332008288354,"total_tps":9809.029562735157,"mean_input_tokens":16384.0,"mean_output_tokens":512.0,"ttft_p50_ms":11890.130738000153,"ttft_p95_ms":21130.08013780927,"ttft_p99_ms":21975.16725305788,"tpot_p50_ms":30.21154287380554,"tpot_p95_ms":50.36428990982482,"tpot_p99_ms":50.89463568451747,"e2e_p50_ms":27717.803564999485,"e2e_p95_ms":27881.70189620141,"e2e_p99_ms":27885.853924593248,"itl_p50_ms":11.294994517811574,"itl_p95_ms":11.584160104393959,"itl_p99_ms":11.971043313969856,"validation_errors":[],"timestamp":"2026-07-17T18:50:46+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":16384,"osl":512,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c16_i16384_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c16_i16384_o512_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":27.627301610977156,"request_tps":1.447843172063782,"input_tps":23721.462531093006,"output_tps":741.2957040966564,"total_tps":24462.75823518966,"mean_input_tokens":16384.0,"mean_output_tokens":512.0,"ttft_p50_ms":773.5901050036773,"ttft_p95_ms":862.7686924577574,"ttft_p99_ms":865.5993688068702,"tpot_p50_ms":9.251504812133089,"tpot_p95_ms":9.736142951728358,"tpot_p99_ms":9.80985083058317,"e2e_p50_ms":5493.54355300602,"e2e_p95_ms":5581.562460951682,"e2e_p99_ms":5584.967895410373,"itl_p50_ms":9.192724493914284,"itl_p95_ms":9.457824158016592,"itl_p99_ms":9.804764903383331,"validation_errors":[],"timestamp":"2026-07-17T18:51:49+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":16384,"osl":512,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c8_i16384_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c8_i16384_o512_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":65.36738938299823,"request_tps":1.2238518434821821,"input_tps":20051.588603612072,"output_tps":1253.2242877257545,"total_tps":21304.812891337828,"mean_input_tokens":16384.0,"mean_output_tokens":1024.0,"ttft_p50_ms":1093.3576795068802,"ttft_p95_ms":2195.3343689834583,"ttft_p99_ms":2198.9187083783327,"tpot_p50_ms":11.369001274183756,"tpot_p95_ms":12.538130341381866,"tpot_p99_ms":12.593227775031968,"e2e_p50_ms":12708.172433514846,"e2e_p95_ms":13813.345123191539,"e2e_p99_ms":13815.3951209574,"itl_p50_ms":11.310051500913687,"itl_p95_ms":11.664677636872511,"itl_p99_ms":12.191684059798717,"validation_errors":[],"timestamp":"2026-07-17T18:53:30+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":16384,"osl":1024,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c16_i16384_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c16_i16384_o1024_a1.log"} +{"status":"COMPLETED","completed":160,"failed":0,"duration_s":185.37672789301723,"request_tps":0.8631072617288703,"input_tps":14141.149376165811,"output_tps":883.8218360103632,"total_tps":15024.971212176175,"mean_input_tokens":16384.0,"mean_output_tokens":1024.0,"ttft_p50_ms":1987.7325069974177,"ttft_p95_ms":38848.21541114068,"ttft_p99_ms":43219.467884287,"tpot_p50_ms":19.470962199419127,"tpot_p95_ms":49.210798451515075,"tpot_p99_ms":53.74089329421399,"e2e_p50_ms":37976.72250700998,"e2e_p95_ms":57761.52874255495,"e2e_p99_ms":57768.16487114818,"itl_p50_ms":13.623770500998944,"itl_p95_ms":14.07611934118904,"itl_p99_ms":14.79364557075314,"validation_errors":[],"timestamp":"2026-07-17T18:57:27+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":16384,"osl":1024,"concurrency":32,"num_prompts":160,"warmup_requests":32,"attempt":1,"gain_pct":-29.476164,"plateau_streak":1,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c32_i16384_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c32_i16384_o1024_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":224.52866718900623,"request_tps":0.3563019413136084,"input_tps":5837.65100648216,"output_tps":729.70637581027,"total_tps":6567.357382292429,"mean_input_tokens":16384.0,"mean_output_tokens":2048.0,"ttft_p50_ms":11878.880584496073,"ttft_p95_ms":21074.74521876429,"ttft_p99_ms":21935.95884875278,"tpot_p50_ms":16.00087163336614,"tpot_p95_ms":21.039388747775636,"tpot_p99_ms":21.16264810100723,"e2e_p50_ms":45090.25657748862,"e2e_p95_ms":45176.080613493104,"e2e_p99_ms":45179.23080949986,"itl_p50_ms":11.293272487819195,"itl_p95_ms":11.68617929361062,"itl_p99_ms":12.241514857450966,"validation_errors":[],"timestamp":"2026-07-17T19:02:00+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":16384,"osl":2048,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c16_i16384_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c16_i16384_o2048_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":99.4930818270077,"request_tps":0.4020380037031065,"input_tps":6586.990652671697,"output_tps":823.3738315839621,"total_tps":7410.364484255659,"mean_input_tokens":16384.0,"mean_output_tokens":2048.0,"ttft_p50_ms":747.6767665066291,"ttft_p95_ms":1876.0424132022308,"ttft_p99_ms":1878.5989462202997,"tpot_p50_ms":9.249578711774841,"tpot_p95_ms":9.367646601504754,"tpot_p99_ms":9.634165814177024,"e2e_p50_ms":19702.27144350065,"e2e_p95_ms":20711.260720560676,"e2e_p99_ms":20716.690592146188,"itl_p50_ms":9.23270802013576,"itl_p95_ms":9.518159051367547,"itl_p99_ms":9.927695452643093,"validation_errors":[],"timestamp":"2026-07-17T19:04:24+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":16384,"osl":2048,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c8_i16384_o2048_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c8_i16384_o2048_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":511.9052273440175,"request_tps":0.15627892767392532,"input_tps":10241.89580403837,"output_tps":20.00370274226244,"total_tps":10261.899506780632,"mean_input_tokens":65536.0,"mean_output_tokens":128.0,"ttft_p50_ms":53315.57349549257,"ttft_p95_ms":101134.38464109204,"ttft_p99_ms":107862.68116299786,"tpot_p50_ms":380.44618120484375,"tpot_p95_ms":750.3071116810843,"tpot_p99_ms":800.4508286104034,"e2e_p50_ms":102934.47444500634,"e2e_p95_ms":114936.24798883393,"e2e_p99_ms":114945.4528501397,"itl_p50_ms":11.860953993164003,"itl_p95_ms":12.212622757942881,"itl_p99_ms":38.48791404045187,"validation_errors":[],"timestamp":"2026-07-17T19:13:41+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":65536,"osl":128,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c16_i65536_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c16_i65536_o128_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":257.13744927800144,"request_tps":0.15555882704877586,"input_tps":10194.703289468574,"output_tps":19.91152986224331,"total_tps":10214.614819330818,"mean_input_tokens":65536.0,"mean_output_tokens":128.0,"ttft_p50_ms":27024.553541486966,"ttft_p95_ms":50240.80516371614,"ttft_p99_ms":51646.51479898166,"tpot_p50_ms":184.6541684686012,"tpot_p95_ms":352.7839763001671,"tpot_p99_ms":372.9480183690508,"e2e_p50_ms":51448.2314404886,"e2e_p95_ms":53666.060027093044,"e2e_p99_ms":53671.051604989625,"itl_p50_ms":9.453045000554994,"itl_p95_ms":9.674875797645656,"itl_p99_ms":18.339120448217727,"validation_errors":[],"timestamp":"2026-07-17T19:18:45+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":65536,"osl":128,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c8_i65536_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c8_i65536_o128_a1.log"} +{"status":"COMPLETED","completed":5,"failed":0,"duration_s":31.20782841197797,"request_tps":0.16021621030449318,"input_tps":10499.929558515265,"output_tps":20.507674918975127,"total_tps":10520.43723343424,"mean_input_tokens":65536.0,"mean_output_tokens":128.0,"ttft_p50_ms":6457.092675002059,"ttft_p95_ms":6495.605285401689,"ttft_p99_ms":6502.828856279375,"tpot_p50_ms":7.538785259871868,"tpot_p95_ms":7.606540730646555,"tpot_p99_ms":7.61853091139163,"e2e_p50_ms":7414.516769000329,"e2e_p95_ms":7455.132690601749,"e2e_p99_ms":7460.674919722369,"itl_p50_ms":7.548149005742744,"itl_p95_ms":7.645344588672742,"itl_p99_ms":7.684663731488399,"validation_errors":[],"timestamp":"2026-07-17T19:19:57+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":65536,"osl":128,"concurrency":1,"num_prompts":5,"warmup_requests":1,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c1_i65536_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c1_i65536_o128_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":488.2059310009936,"request_tps":0.16386527676132878,"input_tps":10739.074777830443,"output_tps":41.94951085090017,"total_tps":10781.024288681343,"mean_input_tokens":65536.0,"mean_output_tokens":256.0,"ttft_p50_ms":48564.19813200773,"ttft_p95_ms":95385.36125675162,"ttft_p99_ms":100211.24193623604,"tpot_p50_ms":195.70179347835673,"tpot_p95_ms":356.2563038080549,"tpot_p99_ms":377.9287777651277,"e2e_p50_ms":102830.53124448634,"e2e_p95_ms":103576.66925156809,"e2e_p99_ms":103588.86407463055,"itl_p50_ms":11.86665399291087,"itl_p95_ms":12.10697204369353,"itl_p99_ms":12.541565755673217,"validation_errors":[],"timestamp":"2026-07-17T19:28:46+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":65536,"osl":256,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c16_i65536_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c16_i65536_o256_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":257.28260668501025,"request_tps":0.15547106162901944,"input_tps":10188.951494919418,"output_tps":39.80059177702898,"total_tps":10228.752086696448,"mean_input_tokens":65536.0,"mean_output_tokens":256.0,"ttft_p50_ms":25800.137330501457,"ttft_p95_ms":50216.99844261748,"ttft_p99_ms":50244.567355921026,"tpot_p50_ms":93.59794155878298,"tpot_p95_ms":179.39680939261214,"tpot_p99_ms":179.54015913548852,"e2e_p50_ms":52654.54371999658,"e2e_p95_ms":52676.85940904339,"e2e_p99_ms":52679.97304955905,"itl_p50_ms":9.446712501812726,"itl_p95_ms":9.65732419717824,"itl_p99_ms":9.9549900132115,"validation_errors":[],"timestamp":"2026-07-17T19:33:48+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":65536,"osl":256,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c8_i65536_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c8_i65536_o256_a1.log"} +{"status":"COMPLETED","completed":5,"failed":0,"duration_s":36.079469299002085,"request_tps":0.13858296968182662,"input_tps":9082.17350106819,"output_tps":35.477240238547616,"total_tps":9117.650741306736,"mean_input_tokens":65536.0,"mean_output_tokens":256.0,"ttft_p50_ms":6466.17098301067,"ttft_p95_ms":6508.5243495879695,"ttft_p99_ms":6515.649347505532,"tpot_p50_ms":7.544317094075001,"tpot_p95_ms":7.615797854937138,"tpot_p99_ms":7.629930011795688,"e2e_p50_ms":8396.909313014476,"e2e_p95_ms":8435.394194582477,"e2e_p99_ms":8439.932221295312,"itl_p50_ms":7.549444009782746,"itl_p95_ms":7.646646397188306,"itl_p99_ms":7.6796751748770475,"validation_errors":[],"timestamp":"2026-07-17T19:35:17+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":65536,"osl":256,"concurrency":1,"num_prompts":5,"warmup_requests":1,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c1_i65536_o256_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c1_i65536_o256_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":498.90946594497655,"request_tps":0.1603497336906071,"input_tps":10508.680147147626,"output_tps":82.09906364959083,"total_tps":10590.779210797218,"mean_input_tokens":65536.0,"mean_output_tokens":512.0,"ttft_p50_ms":47911.28023750207,"ttft_p95_ms":94724.87255284503,"ttft_p99_ms":99662.2306283895,"tpot_p50_ms":102.11882517415528,"tpot_p95_ms":182.86729780979883,"tpot_p99_ms":193.447125787219,"e2e_p50_ms":105411.60414999467,"e2e_p95_ms":106417.34881291195,"e2e_p99_ms":106427.18854085077,"itl_p50_ms":11.860291502671316,"itl_p95_ms":12.195007197442465,"itl_p99_ms":12.680822879483456,"validation_errors":[],"timestamp":"2026-07-17T19:44:25+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":65536,"osl":512,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c16_i65536_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c16_i65536_o512_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":269.06736172598903,"request_tps":0.14866165759909195,"input_tps":9742.69039241409,"output_tps":76.11476869073508,"total_tps":9818.805161104825,"mean_input_tokens":65536.0,"mean_output_tokens":512.0,"ttft_p50_ms":25781.869317492237,"ttft_p95_ms":50126.977651285415,"ttft_p99_ms":50184.97957149026,"tpot_p50_ms":51.40193471720478,"tpot_p95_ms":94.14971120394229,"tpot_p99_ms":94.1969927595483,"e2e_p50_ms":54986.77549450076,"e2e_p95_ms":55053.01765302138,"e2e_p99_ms":55057.20606698276,"itl_p50_ms":9.441087502636947,"itl_p95_ms":9.68292740144534,"itl_p99_ms":9.93578055582475,"validation_errors":[],"timestamp":"2026-07-17T19:49:48+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":65536,"osl":512,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c8_i65536_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c8_i65536_o512_a1.log"} +{"status":"COMPLETED","completed":5,"failed":0,"duration_s":45.791406233998714,"request_tps":0.10919079388934891,"input_tps":7155.92786833237,"output_tps":55.90568647134664,"total_tps":7211.833554803717,"mean_input_tokens":65536.0,"mean_output_tokens":512.0,"ttft_p50_ms":6460.629707988119,"ttft_p95_ms":6539.006657805294,"ttft_p99_ms":6554.323523566127,"tpot_p50_ms":7.545219168295708,"tpot_p95_ms":7.616541197228678,"tpot_p99_ms":7.629570777187627,"e2e_p50_ms":10315.739858982852,"e2e_p95_ms":10403.567293001106,"e2e_p99_ms":10411.721246604575,"itl_p50_ms":7.552191003924236,"itl_p95_ms":7.6516849076142535,"itl_p99_ms":7.674978660652414,"validation_errors":[],"timestamp":"2026-07-17T19:51:19+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":65536,"osl":512,"concurrency":1,"num_prompts":5,"warmup_requests":1,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c1_i65536_o512_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c1_i65536_o512_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":528.7643046409939,"request_tps":0.15129614328697213,"input_tps":9915.344046455006,"output_tps":154.92725072585947,"total_tps":10070.271297180865,"mean_input_tokens":65536.0,"mean_output_tokens":1024.0,"ttft_p50_ms":47916.03667399613,"ttft_p95_ms":94410.50876505759,"ttft_p99_ms":99557.551382659,"tpot_p50_ms":56.908675475076876,"tpot_p95_ms":97.0717138540467,"tpot_p99_ms":102.49631514897438,"e2e_p50_ms":111421.02537148457,"e2e_p95_ms":112132.05178235803,"e2e_p99_ms":112142.33163800294,"itl_p50_ms":11.855768520035781,"itl_p95_ms":12.125714044668712,"itl_p99_ms":12.443589921458624,"validation_errors":[],"timestamp":"2026-07-17T20:00:49+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":65536,"osl":1024,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c16_i65536_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c16_i65536_o1024_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":293.2737799449824,"request_tps":0.1363913269283873,"input_tps":8938.54200157879,"output_tps":139.6647187746686,"total_tps":9078.206720353457,"mean_input_tokens":65536.0,"mean_output_tokens":1024.0,"ttft_p50_ms":25768.77449748281,"ttft_p95_ms":50152.39264675183,"ttft_p99_ms":50188.426944932144,"tpot_p50_ms":30.387320838705204,"tpot_p95_ms":51.754515268101635,"tpot_p99_ms":51.7716177672597,"e2e_p50_ms":59833.17174199328,"e2e_p95_ms":59891.803586500464,"e2e_p99_ms":59893.98450514331,"itl_p50_ms":9.43162350449711,"itl_p95_ms":9.67944530711975,"itl_p99_ms":9.965750366682187,"validation_errors":[],"timestamp":"2026-07-17T20:06:26+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":65536,"osl":1024,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c8_i65536_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c8_i65536_o1024_a1.log"} +{"status":"COMPLETED","completed":5,"failed":0,"duration_s":65.05274701700546,"request_tps":0.07686070503207111,"input_tps":5037.143164981812,"output_tps":78.70536195284082,"total_tps":5115.848526934653,"mean_input_tokens":65536.0,"mean_output_tokens":1024.0,"ttft_p50_ms":6452.015916991513,"ttft_p95_ms":6509.8233474069275,"ttft_p99_ms":6520.219519890379,"tpot_p50_ms":7.5468483646065705,"tpot_p95_ms":7.591814804897996,"tpot_p99_ms":7.600480548479619,"e2e_p50_ms":14171.929251984693,"e2e_p95_ms":14243.005934002576,"e2e_p99_ms":14244.537050802028,"itl_p50_ms":7.54825901822187,"itl_p95_ms":7.646666903747246,"itl_p99_ms":7.701256079599261,"validation_errors":[],"timestamp":"2026-07-17T20:08:22+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":65536,"osl":1024,"concurrency":1,"num_prompts":5,"warmup_requests":1,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c1_i65536_o1024_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c1_i65536_o1024_a1.log"} +{"status":"COMPLETED","completed":80,"failed":0,"duration_s":1174.5449841539958,"request_tps":0.06811148238619621,"input_tps":8927.50821932351,"output_tps":8.718269745433116,"total_tps":8936.226489068944,"mean_input_tokens":131072.0,"mean_output_tokens":128.0,"ttft_p50_ms":118984.38015850843,"ttft_p95_ms":227872.2943032524,"ttft_p99_ms":239851.23607663318,"tpot_p50_ms":896.435555283532,"tpot_p95_ms":1695.026634136473,"tpot_p99_ms":1768.536410790269,"e2e_p50_ms":235326.83629749226,"e2e_p95_ms":245170.37484324828,"e2e_p99_ms":245188.6287166379,"itl_p50_ms":12.406697511323728,"itl_p95_ms":13.077933406748343,"itl_p99_ms":60.79572863323846,"validation_errors":[],"timestamp":"2026-07-17T20:28:58+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":131072,"osl":128,"concurrency":16,"num_prompts":80,"warmup_requests":16,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c16_i131072_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c16_i131072_o128_a1.log"} +{"status":"COMPLETED","completed":40,"failed":0,"duration_s":580.6944100180117,"request_tps":0.06888304641809674,"input_tps":9028.638660112776,"output_tps":8.817029941516383,"total_tps":9037.455690054292,"mean_input_tokens":131072.0,"mean_output_tokens":128.0,"ttft_p50_ms":59963.10726599768,"ttft_p95_ms":116855.13547233713,"ttft_p99_ms":119150.63104747736,"tpot_p50_ms":416.65246549995584,"tpot_p95_ms":808.6195728973271,"tpot_p99_ms":829.7910421426426,"e2e_p50_ms":118130.03293600923,"e2e_p95_ms":121873.5183623794,"e2e_p99_ms":122159.64833238744,"itl_p50_ms":9.791435993975028,"itl_p95_ms":10.017858954961412,"itl_p99_ms":37.10068381566091,"validation_errors":[],"timestamp":"2026-07-17T20:39:38+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":131072,"osl":128,"concurrency":8,"num_prompts":40,"warmup_requests":8,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c8_i131072_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c8_i131072_o128_a1.log"} +{"status":"COMPLETED","completed":5,"failed":0,"duration_s":65.52457915400737,"request_tps":0.07630724324452542,"input_tps":10001.742986546436,"output_tps":9.767327135299254,"total_tps":10011.510313681734,"mean_input_tokens":131072.0,"mean_output_tokens":128.0,"ttft_p50_ms":14981.536393985152,"ttft_p95_ms":15041.782998217968,"ttft_p99_ms":15053.544085257454,"tpot_p50_ms":7.63246691332008,"tpot_p95_ms":7.633707537013289,"tpot_p99_ms":7.633942080667154,"e2e_p50_ms":15951.054484990891,"e2e_p95_ms":16010.838187404443,"e2e_p99_ms":16022.543927885128,"itl_p50_ms":7.644630008144304,"itl_p95_ms":7.684611208969727,"itl_p99_ms":7.727483759517781,"validation_errors":[],"timestamp":"2026-07-17T20:41:40+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":131072,"osl":128,"concurrency":1,"num_prompts":5,"warmup_requests":1,"attempt":1,"gain_pct":null,"plateau_streak":0,"error_type":"","raw_file":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/raw_outputs/sglang_adaptive_c1_i131072_o128_a1.jsonl","detail_log":"/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/tp8_dp1/logs/sglang_c1_i131072_o128_a1.log"} diff --git a/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/adaptive_shapes.jsonl b/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/adaptive_shapes.jsonl new file mode 100644 index 0000000..3a619b0 --- /dev/null +++ b/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/adaptive_shapes.jsonl @@ -0,0 +1,58 @@ +{"timestamp":"2026-07-17T03:02:57+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":128,"status":"COMPLETED","stop_reason":"TPS_PLATEAU","tested_points":10,"search_cap":512,"max_successful_concurrency":160,"saturation_concurrency":144,"stop_probe_concurrency":160,"best_tps_concurrency":128,"best_total_tps":24218.533538377524,"last_total_tps":20896.955774416667} +{"timestamp":"2026-07-17T03:25:38+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":256,"status":"COMPLETED","stop_reason":"TPS_PLATEAU","tested_points":15,"search_cap":512,"max_successful_concurrency":240,"saturation_concurrency":224,"stop_probe_concurrency":240,"best_tps_concurrency":240,"best_total_tps":20149.40043367764,"last_total_tps":20149.40043367764} +{"timestamp":"2026-07-17T03:58:17+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":512,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":15,"search_cap":512,"max_successful_concurrency":240,"saturation_concurrency":null,"stop_probe_concurrency":240,"best_tps_concurrency":224,"best_total_tps":14510.556922778758,"last_total_tps":12683.628339060699} +{"timestamp":"2026-07-17T04:49:49+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":1024,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":15,"search_cap":512,"max_successful_concurrency":240,"saturation_concurrency":null,"stop_probe_concurrency":240,"best_tps_concurrency":224,"best_total_tps":10464.061773456211,"last_total_tps":9969.152601154745} +{"timestamp":"2026-07-17T05:40:08+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":2048,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":10,"search_cap":512,"max_successful_concurrency":160,"saturation_concurrency":null,"stop_probe_concurrency":160,"best_tps_concurrency":160,"best_total_tps":7165.920914246007,"last_total_tps":7165.920914246007} +{"timestamp":"2026-07-17T08:12:59+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":1024,"osl":4096,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":14,"search_cap":512,"max_successful_concurrency":224,"saturation_concurrency":null,"stop_probe_concurrency":224,"best_tps_concurrency":224,"best_total_tps":6226.953488408162,"last_total_tps":6226.953488408162} +{"timestamp":"2026-07-17T08:21:35+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":128,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":6,"search_cap":512,"max_successful_concurrency":96,"saturation_concurrency":null,"stop_probe_concurrency":96,"best_tps_concurrency":80,"best_total_tps":41660.494982592325,"last_total_tps":22270.41431342428} +{"timestamp":"2026-07-17T08:31:34+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":256,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":6,"search_cap":512,"max_successful_concurrency":96,"saturation_concurrency":null,"stop_probe_concurrency":96,"best_tps_concurrency":80,"best_total_tps":31736.653246447207,"last_total_tps":16950.920845500266} +{"timestamp":"2026-07-17T08:43:59+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":512,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":6,"search_cap":512,"max_successful_concurrency":96,"saturation_concurrency":null,"stop_probe_concurrency":96,"best_tps_concurrency":80,"best_total_tps":21026.710283187298,"last_total_tps":14257.401581106222} +{"timestamp":"2026-07-17T09:01:24+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":1024,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":6,"search_cap":512,"max_successful_concurrency":96,"saturation_concurrency":null,"stop_probe_concurrency":96,"best_tps_concurrency":80,"best_total_tps":13798.009301581149,"last_total_tps":11216.004913009716} +{"timestamp":"2026-07-17T09:29:00+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":2048,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":6,"search_cap":512,"max_successful_concurrency":96,"saturation_concurrency":null,"stop_probe_concurrency":96,"best_tps_concurrency":80,"best_total_tps":8849.759539925572,"last_total_tps":8471.829160413403} +{"timestamp":"2026-07-17T09:47:43+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":4096,"osl":4096,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":3,"search_cap":512,"max_successful_concurrency":48,"saturation_concurrency":null,"stop_probe_concurrency":48,"best_tps_concurrency":48,"best_total_tps":4957.290960868959,"last_total_tps":4957.290960868959} +{"timestamp":"2026-07-17T09:50:14+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":16384,"osl":128,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_BACKOFF_FOUND","tested_points":2,"search_cap":512,"max_successful_concurrency":8,"saturation_concurrency":null,"stop_probe_concurrency":8,"best_tps_concurrency":8,"best_total_tps":45151.84310219225,"last_total_tps":45151.84310219225} +{"timestamp":"2026-07-17T09:53:36+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":16384,"osl":256,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":2,"search_cap":512,"max_successful_concurrency":32,"saturation_concurrency":null,"stop_probe_concurrency":32,"best_tps_concurrency":16,"best_total_tps":42533.99259206337,"last_total_tps":30037.299424555902} +{"timestamp":"2026-07-17T09:57:10+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":16384,"osl":512,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_BACKOFF_FOUND","tested_points":2,"search_cap":512,"max_successful_concurrency":8,"saturation_concurrency":null,"stop_probe_concurrency":8,"best_tps_concurrency":8,"best_total_tps":21072.54759075096,"last_total_tps":21072.54759075096} +{"timestamp":"2026-07-17T10:02:22+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":16384,"osl":1024,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":2,"search_cap":512,"max_successful_concurrency":32,"saturation_concurrency":null,"stop_probe_concurrency":32,"best_tps_concurrency":32,"best_total_tps":18269.061756587642,"last_total_tps":18269.061756587642} +{"timestamp":"2026-07-17T10:08:56+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":16384,"osl":2048,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_BACKOFF_FOUND","tested_points":2,"search_cap":512,"max_successful_concurrency":8,"saturation_concurrency":null,"stop_probe_concurrency":8,"best_tps_concurrency":16,"best_total_tps":8010.507208814893,"last_total_tps":6202.246015879342} +{"timestamp":"2026-07-17T10:19:15+00:00","engine":"sglang","tp":2,"dp":4,"mark":"Y","isl":65536,"osl":128,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_GROUP_SKIP_THRESHOLD","tested_points":3,"search_cap":512,"max_successful_concurrency":1,"saturation_concurrency":null,"stop_probe_concurrency":1,"best_tps_concurrency":16,"best_total_tps":21161.91201514059,"last_total_tps":4771.883503028429} +{"timestamp":"2026-07-17T10:41:13+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":128,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":5,"search_cap":512,"max_successful_concurrency":80,"saturation_concurrency":null,"stop_probe_concurrency":80,"best_tps_concurrency":80,"best_total_tps":20064.847256749188,"last_total_tps":20064.847256749188} +{"timestamp":"2026-07-17T10:49:35+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":256,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":7,"search_cap":512,"max_successful_concurrency":112,"saturation_concurrency":null,"stop_probe_concurrency":112,"best_tps_concurrency":112,"best_total_tps":16998.193925507032,"last_total_tps":16998.193925507032} +{"timestamp":"2026-07-17T11:16:42+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":512,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":14,"search_cap":512,"max_successful_concurrency":224,"saturation_concurrency":null,"stop_probe_concurrency":224,"best_tps_concurrency":224,"best_total_tps":16290.664734334032,"last_total_tps":16290.664734334032} +{"timestamp":"2026-07-17T11:59:08+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":1024,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":14,"search_cap":512,"max_successful_concurrency":224,"saturation_concurrency":null,"stop_probe_concurrency":224,"best_tps_concurrency":224,"best_total_tps":11924.700934652748,"last_total_tps":11924.700934652748} +{"timestamp":"2026-07-17T12:32:03+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":2048,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":8,"search_cap":512,"max_successful_concurrency":128,"saturation_concurrency":null,"stop_probe_concurrency":128,"best_tps_concurrency":128,"best_total_tps":7347.710241657577,"last_total_tps":7347.710241657577} +{"timestamp":"2026-07-17T13:57:11+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":1024,"osl":4096,"status":"COMPLETED","stop_reason":"TPS_PLATEAU","tested_points":10,"search_cap":512,"max_successful_concurrency":160,"saturation_concurrency":144,"stop_probe_concurrency":160,"best_tps_concurrency":160,"best_total_tps":5792.414649417691,"last_total_tps":5792.414649417691} +{"timestamp":"2026-07-17T14:02:23+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":128,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":5,"search_cap":512,"max_successful_concurrency":80,"saturation_concurrency":null,"stop_probe_concurrency":80,"best_tps_concurrency":80,"best_total_tps":62360.79085845758,"last_total_tps":62360.79085845758} +{"timestamp":"2026-07-17T14:09:26+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":256,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":6,"search_cap":512,"max_successful_concurrency":96,"saturation_concurrency":null,"stop_probe_concurrency":96,"best_tps_concurrency":80,"best_total_tps":48008.51166904608,"last_total_tps":38405.264544958074} +{"timestamp":"2026-07-17T14:20:49+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":512,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":7,"search_cap":512,"max_successful_concurrency":112,"saturation_concurrency":null,"stop_probe_concurrency":112,"best_tps_concurrency":96,"best_total_tps":33192.15058943144,"last_total_tps":29547.10813742353} +{"timestamp":"2026-07-17T14:27:36+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":1024,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":3,"search_cap":512,"max_successful_concurrency":48,"saturation_concurrency":null,"stop_probe_concurrency":48,"best_tps_concurrency":48,"best_total_tps":11401.702019271886,"last_total_tps":11401.702019271886} +{"timestamp":"2026-07-17T14:58:04+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":2048,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":7,"search_cap":512,"max_successful_concurrency":112,"saturation_concurrency":null,"stop_probe_concurrency":112,"best_tps_concurrency":96,"best_total_tps":11627.161961587157,"last_total_tps":9409.041608868225} +{"timestamp":"2026-07-17T15:15:39+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":4096,"osl":4096,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":3,"search_cap":512,"max_successful_concurrency":48,"saturation_concurrency":null,"stop_probe_concurrency":48,"best_tps_concurrency":48,"best_total_tps":5341.490327065961,"last_total_tps":5341.490327065961} +{"timestamp":"2026-07-17T15:18:15+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":16384,"osl":128,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_BACKOFF_FOUND","tested_points":2,"search_cap":512,"max_successful_concurrency":8,"saturation_concurrency":null,"stop_probe_concurrency":8,"best_tps_concurrency":8,"best_total_tps":42435.47732274857,"last_total_tps":42435.47732274857} +{"timestamp":"2026-07-17T15:21:54+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":16384,"osl":256,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":2,"search_cap":512,"max_successful_concurrency":32,"saturation_concurrency":null,"stop_probe_concurrency":32,"best_tps_concurrency":16,"best_total_tps":42184.2844698077,"last_total_tps":25260.17465036972} +{"timestamp":"2026-07-17T15:25:40+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":16384,"osl":512,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_BACKOFF_FOUND","tested_points":2,"search_cap":512,"max_successful_concurrency":8,"saturation_concurrency":null,"stop_probe_concurrency":8,"best_tps_concurrency":8,"best_total_tps":20315.213143648834,"last_total_tps":20315.213143648834} +{"timestamp":"2026-07-17T15:31:00+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":16384,"osl":1024,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":2,"search_cap":512,"max_successful_concurrency":32,"saturation_concurrency":null,"stop_probe_concurrency":32,"best_tps_concurrency":16,"best_total_tps":19718.50327444501,"last_total_tps":16636.697901789463} +{"timestamp":"2026-07-17T15:37:33+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":16384,"osl":2048,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_BACKOFF_FOUND","tested_points":2,"search_cap":512,"max_successful_concurrency":8,"saturation_concurrency":null,"stop_probe_concurrency":8,"best_tps_concurrency":16,"best_total_tps":7595.656062798347,"last_total_tps":6639.92627639857} +{"timestamp":"2026-07-17T15:49:09+00:00","engine":"sglang","tp":4,"dp":2,"mark":"Y","isl":65536,"osl":128,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_GROUP_SKIP_THRESHOLD","tested_points":3,"search_cap":512,"max_successful_concurrency":1,"saturation_concurrency":null,"stop_probe_concurrency":1,"best_tps_concurrency":16,"best_total_tps":15952.971597773088,"last_total_tps":6898.929422081428} +{"timestamp":"2026-07-17T16:11:24+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":128,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":4,"search_cap":512,"max_successful_concurrency":64,"saturation_concurrency":null,"stop_probe_concurrency":64,"best_tps_concurrency":64,"best_total_tps":15612.537562083084,"last_total_tps":15612.537562083084} +{"timestamp":"2026-07-17T16:17:10+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":256,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":5,"search_cap":512,"max_successful_concurrency":80,"saturation_concurrency":null,"stop_probe_concurrency":80,"best_tps_concurrency":64,"best_total_tps":13972.196218473699,"last_total_tps":12761.994994271045} +{"timestamp":"2026-07-17T16:25:57+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":512,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":6,"search_cap":512,"max_successful_concurrency":96,"saturation_concurrency":null,"stop_probe_concurrency":96,"best_tps_concurrency":96,"best_total_tps":10187.39875273473,"last_total_tps":10187.39875273473} +{"timestamp":"2026-07-17T16:42:16+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":1024,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":7,"search_cap":512,"max_successful_concurrency":112,"saturation_concurrency":null,"stop_probe_concurrency":112,"best_tps_concurrency":112,"best_total_tps":8254.49886320328,"last_total_tps":8254.49886320328} +{"timestamp":"2026-07-17T17:09:56+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":2048,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":7,"search_cap":512,"max_successful_concurrency":112,"saturation_concurrency":null,"stop_probe_concurrency":112,"best_tps_concurrency":112,"best_total_tps":6580.543973399365,"last_total_tps":6580.543973399365} +{"timestamp":"2026-07-17T17:59:52+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":1024,"osl":4096,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":7,"search_cap":512,"max_successful_concurrency":112,"saturation_concurrency":null,"stop_probe_concurrency":112,"best_tps_concurrency":112,"best_total_tps":5333.722873915772,"last_total_tps":5333.722873915772} +{"timestamp":"2026-07-17T18:03:08+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":4096,"osl":128,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":3,"search_cap":512,"max_successful_concurrency":48,"saturation_concurrency":null,"stop_probe_concurrency":48,"best_tps_concurrency":32,"best_total_tps":32068.844335167778,"last_total_tps":24363.21064565177} +{"timestamp":"2026-07-17T18:08:07+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":4096,"osl":256,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":4,"search_cap":512,"max_successful_concurrency":64,"saturation_concurrency":null,"stop_probe_concurrency":64,"best_tps_concurrency":48,"best_total_tps":38696.19023732795,"last_total_tps":25264.272565269577} +{"timestamp":"2026-07-17T18:14:07+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":4096,"osl":512,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":4,"search_cap":512,"max_successful_concurrency":64,"saturation_concurrency":null,"stop_probe_concurrency":64,"best_tps_concurrency":48,"best_total_tps":22005.195656396023,"last_total_tps":20556.155426231682} +{"timestamp":"2026-07-17T18:17:44+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":4096,"osl":1024,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_BACKOFF_FOUND","tested_points":2,"search_cap":512,"max_successful_concurrency":8,"saturation_concurrency":null,"stop_probe_concurrency":8,"best_tps_concurrency":16,"best_total_tps":4866.203776874325,"last_total_tps":4179.06484207382} +{"timestamp":"2026-07-17T18:23:44+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":4096,"osl":2048,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":2,"search_cap":512,"max_successful_concurrency":32,"saturation_concurrency":null,"stop_probe_concurrency":32,"best_tps_concurrency":32,"best_total_tps":5901.399976779881,"last_total_tps":5901.399976779881} +{"timestamp":"2026-07-17T18:40:13+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":4096,"osl":4096,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":3,"search_cap":512,"max_successful_concurrency":48,"saturation_concurrency":null,"stop_probe_concurrency":48,"best_tps_concurrency":48,"best_total_tps":5507.291915274797,"last_total_tps":5507.291915274797} +{"timestamp":"2026-07-17T18:43:35+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":16384,"osl":128,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_BACKOFF_FOUND","tested_points":2,"search_cap":512,"max_successful_concurrency":8,"saturation_concurrency":null,"stop_probe_concurrency":8,"best_tps_concurrency":8,"best_total_tps":69448.53298640453,"last_total_tps":69448.53298640453} +{"timestamp":"2026-07-17T18:47:45+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":16384,"osl":256,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":2,"search_cap":512,"max_successful_concurrency":32,"saturation_concurrency":null,"stop_probe_concurrency":32,"best_tps_concurrency":16,"best_total_tps":67210.7404108151,"last_total_tps":19717.993491121175} +{"timestamp":"2026-07-17T18:51:49+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":16384,"osl":512,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_BACKOFF_FOUND","tested_points":2,"search_cap":512,"max_successful_concurrency":8,"saturation_concurrency":null,"stop_probe_concurrency":8,"best_tps_concurrency":8,"best_total_tps":24462.75823518966,"last_total_tps":24462.75823518966} +{"timestamp":"2026-07-17T18:57:27+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":16384,"osl":1024,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":2,"search_cap":512,"max_successful_concurrency":32,"saturation_concurrency":null,"stop_probe_concurrency":32,"best_tps_concurrency":16,"best_total_tps":21304.812891337828,"last_total_tps":15024.971212176175} +{"timestamp":"2026-07-17T19:04:24+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":16384,"osl":2048,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_BACKOFF_FOUND","tested_points":2,"search_cap":512,"max_successful_concurrency":8,"saturation_concurrency":null,"stop_probe_concurrency":8,"best_tps_concurrency":8,"best_total_tps":7410.364484255659,"last_total_tps":7410.364484255659} +{"timestamp":"2026-07-17T19:19:57+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":65536,"osl":128,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":3,"search_cap":512,"max_successful_concurrency":1,"saturation_concurrency":null,"stop_probe_concurrency":1,"best_tps_concurrency":1,"best_total_tps":10520.43723343424,"last_total_tps":10520.43723343424} +{"timestamp":"2026-07-17T19:35:18+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":65536,"osl":256,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":3,"search_cap":512,"max_successful_concurrency":1,"saturation_concurrency":null,"stop_probe_concurrency":1,"best_tps_concurrency":16,"best_total_tps":10781.024288681343,"last_total_tps":9117.650741306736} +{"timestamp":"2026-07-17T19:51:19+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":65536,"osl":512,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":3,"search_cap":512,"max_successful_concurrency":1,"saturation_concurrency":null,"stop_probe_concurrency":1,"best_tps_concurrency":16,"best_total_tps":10590.779210797218,"last_total_tps":7211.833554803717} +{"timestamp":"2026-07-17T20:08:22+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":65536,"osl":1024,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_SLO_EXCEEDED","tested_points":3,"search_cap":512,"max_successful_concurrency":1,"saturation_concurrency":null,"stop_probe_concurrency":1,"best_tps_concurrency":16,"best_total_tps":10070.271297180865,"last_total_tps":5115.848526934653} +{"timestamp":"2026-07-17T20:41:40+00:00","engine":"sglang","tp":8,"dp":1,"mark":"Y","isl":131072,"osl":128,"status":"TTFT_BOUNDARY","stop_reason":"TTFT_GROUP_SKIP_THRESHOLD","tested_points":3,"search_cap":512,"max_successful_concurrency":1,"saturation_concurrency":null,"stop_probe_concurrency":1,"best_tps_concurrency":1,"best_total_tps":10011.510313681734,"last_total_tps":10011.510313681734} diff --git a/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/adaptive_summary.jsonl b/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/adaptive_summary.jsonl new file mode 100644 index 0000000..83aa669 --- /dev/null +++ b/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/adaptive_summary.jsonl @@ -0,0 +1,58 @@ +{"timestamp": "2026-07-17T03:02:57+00:00", "engine": "sglang", "tp": 2, "dp": 4, "mark": "Y", "isl": 1024, "osl": 128, "status": "COMPLETED", "stop_reason": "TPS_PLATEAU", "tested_points": 10, "search_cap": 512, "max_successful_concurrency": 160, "saturation_concurrency": 144, "stop_probe_concurrency": 160, "best_tps_concurrency": 128, "best_total_tps": 24218.533538377524, "last_total_tps": 20896.955774416667} +{"timestamp": "2026-07-17T03:25:38+00:00", "engine": "sglang", "tp": 2, "dp": 4, "mark": "Y", "isl": 1024, "osl": 256, "status": "COMPLETED", "stop_reason": "TPS_PLATEAU", "tested_points": 15, "search_cap": 512, "max_successful_concurrency": 240, "saturation_concurrency": 224, "stop_probe_concurrency": 240, "best_tps_concurrency": 240, "best_total_tps": 20149.40043367764, "last_total_tps": 20149.40043367764} +{"timestamp": "2026-07-17T03:58:17+00:00", "engine": "sglang", "tp": 2, "dp": 4, "mark": "Y", "isl": 1024, "osl": 512, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 15, "search_cap": 512, "max_successful_concurrency": 240, "saturation_concurrency": null, "stop_probe_concurrency": 240, "best_tps_concurrency": 224, "best_total_tps": 14510.556922778758, "last_total_tps": 12683.628339060699} +{"timestamp": "2026-07-17T04:49:49+00:00", "engine": "sglang", "tp": 2, "dp": 4, "mark": "Y", "isl": 1024, "osl": 1024, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 15, "search_cap": 512, "max_successful_concurrency": 240, "saturation_concurrency": null, "stop_probe_concurrency": 240, "best_tps_concurrency": 224, "best_total_tps": 10464.061773456211, "last_total_tps": 9969.152601154745} +{"timestamp": "2026-07-17T05:40:08+00:00", "engine": "sglang", "tp": 2, "dp": 4, "mark": "Y", "isl": 1024, "osl": 2048, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 10, "search_cap": 512, "max_successful_concurrency": 160, "saturation_concurrency": null, "stop_probe_concurrency": 160, "best_tps_concurrency": 160, "best_total_tps": 7165.920914246007, "last_total_tps": 7165.920914246007} +{"timestamp": "2026-07-17T08:12:59+00:00", "engine": "sglang", "tp": 2, "dp": 4, "mark": "Y", "isl": 1024, "osl": 4096, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 14, "search_cap": 512, "max_successful_concurrency": 224, "saturation_concurrency": null, "stop_probe_concurrency": 224, "best_tps_concurrency": 224, "best_total_tps": 6226.953488408162, "last_total_tps": 6226.953488408162} +{"timestamp": "2026-07-17T08:21:35+00:00", "engine": "sglang", "tp": 2, "dp": 4, "mark": "Y", "isl": 4096, "osl": 128, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 6, "search_cap": 512, "max_successful_concurrency": 96, "saturation_concurrency": null, "stop_probe_concurrency": 96, "best_tps_concurrency": 80, "best_total_tps": 41660.494982592325, "last_total_tps": 22270.41431342428} +{"timestamp": "2026-07-17T08:31:34+00:00", "engine": "sglang", "tp": 2, "dp": 4, "mark": "Y", "isl": 4096, "osl": 256, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 6, "search_cap": 512, "max_successful_concurrency": 96, "saturation_concurrency": null, "stop_probe_concurrency": 96, "best_tps_concurrency": 80, "best_total_tps": 31736.653246447207, "last_total_tps": 16950.920845500266} +{"timestamp": "2026-07-17T08:43:59+00:00", "engine": "sglang", "tp": 2, "dp": 4, "mark": "Y", "isl": 4096, "osl": 512, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 6, "search_cap": 512, "max_successful_concurrency": 96, "saturation_concurrency": null, "stop_probe_concurrency": 96, "best_tps_concurrency": 80, "best_total_tps": 21026.710283187298, "last_total_tps": 14257.401581106222} +{"timestamp": "2026-07-17T09:01:24+00:00", "engine": "sglang", "tp": 2, "dp": 4, "mark": "Y", "isl": 4096, "osl": 1024, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 6, "search_cap": 512, "max_successful_concurrency": 96, "saturation_concurrency": null, "stop_probe_concurrency": 96, "best_tps_concurrency": 80, "best_total_tps": 13798.009301581149, "last_total_tps": 11216.004913009716} +{"timestamp": "2026-07-17T09:29:00+00:00", "engine": "sglang", "tp": 2, "dp": 4, "mark": "Y", "isl": 4096, "osl": 2048, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 6, "search_cap": 512, "max_successful_concurrency": 96, "saturation_concurrency": null, "stop_probe_concurrency": 96, "best_tps_concurrency": 80, "best_total_tps": 8849.759539925572, "last_total_tps": 8471.829160413403} +{"timestamp": "2026-07-17T09:47:43+00:00", "engine": "sglang", "tp": 2, "dp": 4, "mark": "Y", "isl": 4096, "osl": 4096, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 48, "saturation_concurrency": null, "stop_probe_concurrency": 48, "best_tps_concurrency": 48, "best_total_tps": 4957.290960868959, "last_total_tps": 4957.290960868959} +{"timestamp": "2026-07-17T09:50:14+00:00", "engine": "sglang", "tp": 2, "dp": 4, "mark": "Y", "isl": 16384, "osl": 128, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_BACKOFF_FOUND", "tested_points": 2, "search_cap": 512, "max_successful_concurrency": 8, "saturation_concurrency": null, "stop_probe_concurrency": 8, "best_tps_concurrency": 8, "best_total_tps": 45151.84310219225, "last_total_tps": 45151.84310219225} +{"timestamp": "2026-07-17T09:53:36+00:00", "engine": "sglang", "tp": 2, "dp": 4, "mark": "Y", "isl": 16384, "osl": 256, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 2, "search_cap": 512, "max_successful_concurrency": 32, "saturation_concurrency": null, "stop_probe_concurrency": 32, "best_tps_concurrency": 16, "best_total_tps": 42533.99259206337, "last_total_tps": 30037.299424555902} +{"timestamp": "2026-07-17T09:57:10+00:00", "engine": "sglang", "tp": 2, "dp": 4, "mark": "Y", "isl": 16384, "osl": 512, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_BACKOFF_FOUND", "tested_points": 2, "search_cap": 512, "max_successful_concurrency": 8, "saturation_concurrency": null, "stop_probe_concurrency": 8, "best_tps_concurrency": 8, "best_total_tps": 21072.54759075096, "last_total_tps": 21072.54759075096} +{"timestamp": "2026-07-17T10:02:22+00:00", "engine": "sglang", "tp": 2, "dp": 4, "mark": "Y", "isl": 16384, "osl": 1024, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 2, "search_cap": 512, "max_successful_concurrency": 32, "saturation_concurrency": null, "stop_probe_concurrency": 32, "best_tps_concurrency": 32, "best_total_tps": 18269.061756587642, "last_total_tps": 18269.061756587642} +{"timestamp": "2026-07-17T10:08:56+00:00", "engine": "sglang", "tp": 2, "dp": 4, "mark": "Y", "isl": 16384, "osl": 2048, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_BACKOFF_FOUND", "tested_points": 2, "search_cap": 512, "max_successful_concurrency": 8, "saturation_concurrency": null, "stop_probe_concurrency": 8, "best_tps_concurrency": 16, "best_total_tps": 8010.507208814893, "last_total_tps": 6202.246015879342} +{"timestamp": "2026-07-17T10:19:15+00:00", "engine": "sglang", "tp": 2, "dp": 4, "mark": "Y", "isl": 65536, "osl": 128, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_GROUP_SKIP_THRESHOLD", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 1, "saturation_concurrency": null, "stop_probe_concurrency": 1, "best_tps_concurrency": 16, "best_total_tps": 21161.91201514059, "last_total_tps": 4771.883503028429} +{"timestamp": "2026-07-17T10:41:13+00:00", "engine": "sglang", "tp": 4, "dp": 2, "mark": "Y", "isl": 1024, "osl": 128, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 5, "search_cap": 512, "max_successful_concurrency": 80, "saturation_concurrency": null, "stop_probe_concurrency": 80, "best_tps_concurrency": 80, "best_total_tps": 20064.847256749188, "last_total_tps": 20064.847256749188} +{"timestamp": "2026-07-17T10:49:35+00:00", "engine": "sglang", "tp": 4, "dp": 2, "mark": "Y", "isl": 1024, "osl": 256, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 7, "search_cap": 512, "max_successful_concurrency": 112, "saturation_concurrency": null, "stop_probe_concurrency": 112, "best_tps_concurrency": 112, "best_total_tps": 16998.193925507032, "last_total_tps": 16998.193925507032} +{"timestamp": "2026-07-17T11:16:42+00:00", "engine": "sglang", "tp": 4, "dp": 2, "mark": "Y", "isl": 1024, "osl": 512, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 14, "search_cap": 512, "max_successful_concurrency": 224, "saturation_concurrency": null, "stop_probe_concurrency": 224, "best_tps_concurrency": 224, "best_total_tps": 16290.664734334032, "last_total_tps": 16290.664734334032} +{"timestamp": "2026-07-17T11:59:08+00:00", "engine": "sglang", "tp": 4, "dp": 2, "mark": "Y", "isl": 1024, "osl": 1024, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 14, "search_cap": 512, "max_successful_concurrency": 224, "saturation_concurrency": null, "stop_probe_concurrency": 224, "best_tps_concurrency": 224, "best_total_tps": 11924.700934652748, "last_total_tps": 11924.700934652748} +{"timestamp": "2026-07-17T12:32:03+00:00", "engine": "sglang", "tp": 4, "dp": 2, "mark": "Y", "isl": 1024, "osl": 2048, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 8, "search_cap": 512, "max_successful_concurrency": 128, "saturation_concurrency": null, "stop_probe_concurrency": 128, "best_tps_concurrency": 128, "best_total_tps": 7347.710241657577, "last_total_tps": 7347.710241657577} +{"timestamp": "2026-07-17T13:57:11+00:00", "engine": "sglang", "tp": 4, "dp": 2, "mark": "Y", "isl": 1024, "osl": 4096, "status": "COMPLETED", "stop_reason": "TPS_PLATEAU", "tested_points": 10, "search_cap": 512, "max_successful_concurrency": 160, "saturation_concurrency": 144, "stop_probe_concurrency": 160, "best_tps_concurrency": 160, "best_total_tps": 5792.414649417691, "last_total_tps": 5792.414649417691} +{"timestamp": "2026-07-17T14:02:23+00:00", "engine": "sglang", "tp": 4, "dp": 2, "mark": "Y", "isl": 4096, "osl": 128, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 5, "search_cap": 512, "max_successful_concurrency": 80, "saturation_concurrency": null, "stop_probe_concurrency": 80, "best_tps_concurrency": 80, "best_total_tps": 62360.79085845758, "last_total_tps": 62360.79085845758} +{"timestamp": "2026-07-17T14:09:26+00:00", "engine": "sglang", "tp": 4, "dp": 2, "mark": "Y", "isl": 4096, "osl": 256, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 6, "search_cap": 512, "max_successful_concurrency": 96, "saturation_concurrency": null, "stop_probe_concurrency": 96, "best_tps_concurrency": 80, "best_total_tps": 48008.51166904608, "last_total_tps": 38405.264544958074} +{"timestamp": "2026-07-17T14:20:49+00:00", "engine": "sglang", "tp": 4, "dp": 2, "mark": "Y", "isl": 4096, "osl": 512, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 7, "search_cap": 512, "max_successful_concurrency": 112, "saturation_concurrency": null, "stop_probe_concurrency": 112, "best_tps_concurrency": 96, "best_total_tps": 33192.15058943144, "last_total_tps": 29547.10813742353} +{"timestamp": "2026-07-17T14:27:36+00:00", "engine": "sglang", "tp": 4, "dp": 2, "mark": "Y", "isl": 4096, "osl": 1024, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 48, "saturation_concurrency": null, "stop_probe_concurrency": 48, "best_tps_concurrency": 48, "best_total_tps": 11401.702019271886, "last_total_tps": 11401.702019271886} +{"timestamp": "2026-07-17T14:58:04+00:00", "engine": "sglang", "tp": 4, "dp": 2, "mark": "Y", "isl": 4096, "osl": 2048, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 7, "search_cap": 512, "max_successful_concurrency": 112, "saturation_concurrency": null, "stop_probe_concurrency": 112, "best_tps_concurrency": 96, "best_total_tps": 11627.161961587157, "last_total_tps": 9409.041608868225} +{"timestamp": "2026-07-17T15:15:39+00:00", "engine": "sglang", "tp": 4, "dp": 2, "mark": "Y", "isl": 4096, "osl": 4096, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 48, "saturation_concurrency": null, "stop_probe_concurrency": 48, "best_tps_concurrency": 48, "best_total_tps": 5341.490327065961, "last_total_tps": 5341.490327065961} +{"timestamp": "2026-07-17T15:18:15+00:00", "engine": "sglang", "tp": 4, "dp": 2, "mark": "Y", "isl": 16384, "osl": 128, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_BACKOFF_FOUND", "tested_points": 2, "search_cap": 512, "max_successful_concurrency": 8, "saturation_concurrency": null, "stop_probe_concurrency": 8, "best_tps_concurrency": 8, "best_total_tps": 42435.47732274857, "last_total_tps": 42435.47732274857} +{"timestamp": "2026-07-17T15:21:54+00:00", "engine": "sglang", "tp": 4, "dp": 2, "mark": "Y", "isl": 16384, "osl": 256, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 2, "search_cap": 512, "max_successful_concurrency": 32, "saturation_concurrency": null, "stop_probe_concurrency": 32, "best_tps_concurrency": 16, "best_total_tps": 42184.2844698077, "last_total_tps": 25260.17465036972} +{"timestamp": "2026-07-17T15:25:40+00:00", "engine": "sglang", "tp": 4, "dp": 2, "mark": "Y", "isl": 16384, "osl": 512, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_BACKOFF_FOUND", "tested_points": 2, "search_cap": 512, "max_successful_concurrency": 8, "saturation_concurrency": null, "stop_probe_concurrency": 8, "best_tps_concurrency": 8, "best_total_tps": 20315.213143648834, "last_total_tps": 20315.213143648834} +{"timestamp": "2026-07-17T15:31:00+00:00", "engine": "sglang", "tp": 4, "dp": 2, "mark": "Y", "isl": 16384, "osl": 1024, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 2, "search_cap": 512, "max_successful_concurrency": 32, "saturation_concurrency": null, "stop_probe_concurrency": 32, "best_tps_concurrency": 16, "best_total_tps": 19718.50327444501, "last_total_tps": 16636.697901789463} +{"timestamp": "2026-07-17T15:37:33+00:00", "engine": "sglang", "tp": 4, "dp": 2, "mark": "Y", "isl": 16384, "osl": 2048, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_BACKOFF_FOUND", "tested_points": 2, "search_cap": 512, "max_successful_concurrency": 8, "saturation_concurrency": null, "stop_probe_concurrency": 8, "best_tps_concurrency": 16, "best_total_tps": 7595.656062798347, "last_total_tps": 6639.92627639857} +{"timestamp": "2026-07-17T15:49:09+00:00", "engine": "sglang", "tp": 4, "dp": 2, "mark": "Y", "isl": 65536, "osl": 128, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_GROUP_SKIP_THRESHOLD", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 1, "saturation_concurrency": null, "stop_probe_concurrency": 1, "best_tps_concurrency": 16, "best_total_tps": 15952.971597773088, "last_total_tps": 6898.929422081428} +{"timestamp": "2026-07-17T16:11:24+00:00", "engine": "sglang", "tp": 8, "dp": 1, "mark": "Y", "isl": 1024, "osl": 128, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 4, "search_cap": 512, "max_successful_concurrency": 64, "saturation_concurrency": null, "stop_probe_concurrency": 64, "best_tps_concurrency": 64, "best_total_tps": 15612.537562083084, "last_total_tps": 15612.537562083084} +{"timestamp": "2026-07-17T16:17:10+00:00", "engine": "sglang", "tp": 8, "dp": 1, "mark": "Y", "isl": 1024, "osl": 256, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 5, "search_cap": 512, "max_successful_concurrency": 80, "saturation_concurrency": null, "stop_probe_concurrency": 80, "best_tps_concurrency": 64, "best_total_tps": 13972.196218473699, "last_total_tps": 12761.994994271045} +{"timestamp": "2026-07-17T16:25:57+00:00", "engine": "sglang", "tp": 8, "dp": 1, "mark": "Y", "isl": 1024, "osl": 512, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 6, "search_cap": 512, "max_successful_concurrency": 96, "saturation_concurrency": null, "stop_probe_concurrency": 96, "best_tps_concurrency": 96, "best_total_tps": 10187.39875273473, "last_total_tps": 10187.39875273473} +{"timestamp": "2026-07-17T16:42:16+00:00", "engine": "sglang", "tp": 8, "dp": 1, "mark": "Y", "isl": 1024, "osl": 1024, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 7, "search_cap": 512, "max_successful_concurrency": 112, "saturation_concurrency": null, "stop_probe_concurrency": 112, "best_tps_concurrency": 112, "best_total_tps": 8254.49886320328, "last_total_tps": 8254.49886320328} +{"timestamp": "2026-07-17T17:09:56+00:00", "engine": "sglang", "tp": 8, "dp": 1, "mark": "Y", "isl": 1024, "osl": 2048, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 7, "search_cap": 512, "max_successful_concurrency": 112, "saturation_concurrency": null, "stop_probe_concurrency": 112, "best_tps_concurrency": 112, "best_total_tps": 6580.543973399365, "last_total_tps": 6580.543973399365} +{"timestamp": "2026-07-17T17:59:52+00:00", "engine": "sglang", "tp": 8, "dp": 1, "mark": "Y", "isl": 1024, "osl": 4096, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 7, "search_cap": 512, "max_successful_concurrency": 112, "saturation_concurrency": null, "stop_probe_concurrency": 112, "best_tps_concurrency": 112, "best_total_tps": 5333.722873915772, "last_total_tps": 5333.722873915772} +{"timestamp": "2026-07-17T18:03:08+00:00", "engine": "sglang", "tp": 8, "dp": 1, "mark": "Y", "isl": 4096, "osl": 128, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 48, "saturation_concurrency": null, "stop_probe_concurrency": 48, "best_tps_concurrency": 32, "best_total_tps": 32068.844335167778, "last_total_tps": 24363.21064565177} +{"timestamp": "2026-07-17T18:08:07+00:00", "engine": "sglang", "tp": 8, "dp": 1, "mark": "Y", "isl": 4096, "osl": 256, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 4, "search_cap": 512, "max_successful_concurrency": 64, "saturation_concurrency": null, "stop_probe_concurrency": 64, "best_tps_concurrency": 48, "best_total_tps": 38696.19023732795, "last_total_tps": 25264.272565269577} +{"timestamp": "2026-07-17T18:14:07+00:00", "engine": "sglang", "tp": 8, "dp": 1, "mark": "Y", "isl": 4096, "osl": 512, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 4, "search_cap": 512, "max_successful_concurrency": 64, "saturation_concurrency": null, "stop_probe_concurrency": 64, "best_tps_concurrency": 48, "best_total_tps": 22005.195656396023, "last_total_tps": 20556.155426231682} +{"timestamp": "2026-07-17T18:17:44+00:00", "engine": "sglang", "tp": 8, "dp": 1, "mark": "Y", "isl": 4096, "osl": 1024, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_BACKOFF_FOUND", "tested_points": 2, "search_cap": 512, "max_successful_concurrency": 8, "saturation_concurrency": null, "stop_probe_concurrency": 8, "best_tps_concurrency": 16, "best_total_tps": 4866.203776874325, "last_total_tps": 4179.06484207382} +{"timestamp": "2026-07-17T18:23:44+00:00", "engine": "sglang", "tp": 8, "dp": 1, "mark": "Y", "isl": 4096, "osl": 2048, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 2, "search_cap": 512, "max_successful_concurrency": 32, "saturation_concurrency": null, "stop_probe_concurrency": 32, "best_tps_concurrency": 32, "best_total_tps": 5901.399976779881, "last_total_tps": 5901.399976779881} +{"timestamp": "2026-07-17T18:40:13+00:00", "engine": "sglang", "tp": 8, "dp": 1, "mark": "Y", "isl": 4096, "osl": 4096, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 48, "saturation_concurrency": null, "stop_probe_concurrency": 48, "best_tps_concurrency": 48, "best_total_tps": 5507.291915274797, "last_total_tps": 5507.291915274797} +{"timestamp": "2026-07-17T18:43:35+00:00", "engine": "sglang", "tp": 8, "dp": 1, "mark": "Y", "isl": 16384, "osl": 128, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_BACKOFF_FOUND", "tested_points": 2, "search_cap": 512, "max_successful_concurrency": 8, "saturation_concurrency": null, "stop_probe_concurrency": 8, "best_tps_concurrency": 8, "best_total_tps": 69448.53298640453, "last_total_tps": 69448.53298640453} +{"timestamp": "2026-07-17T18:47:45+00:00", "engine": "sglang", "tp": 8, "dp": 1, "mark": "Y", "isl": 16384, "osl": 256, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 2, "search_cap": 512, "max_successful_concurrency": 32, "saturation_concurrency": null, "stop_probe_concurrency": 32, "best_tps_concurrency": 16, "best_total_tps": 67210.7404108151, "last_total_tps": 19717.993491121175} +{"timestamp": "2026-07-17T18:51:49+00:00", "engine": "sglang", "tp": 8, "dp": 1, "mark": "Y", "isl": 16384, "osl": 512, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_BACKOFF_FOUND", "tested_points": 2, "search_cap": 512, "max_successful_concurrency": 8, "saturation_concurrency": null, "stop_probe_concurrency": 8, "best_tps_concurrency": 8, "best_total_tps": 24462.75823518966, "last_total_tps": 24462.75823518966} +{"timestamp": "2026-07-17T18:57:27+00:00", "engine": "sglang", "tp": 8, "dp": 1, "mark": "Y", "isl": 16384, "osl": 1024, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 2, "search_cap": 512, "max_successful_concurrency": 32, "saturation_concurrency": null, "stop_probe_concurrency": 32, "best_tps_concurrency": 16, "best_total_tps": 21304.812891337828, "last_total_tps": 15024.971212176175} +{"timestamp": "2026-07-17T19:04:24+00:00", "engine": "sglang", "tp": 8, "dp": 1, "mark": "Y", "isl": 16384, "osl": 2048, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_BACKOFF_FOUND", "tested_points": 2, "search_cap": 512, "max_successful_concurrency": 8, "saturation_concurrency": null, "stop_probe_concurrency": 8, "best_tps_concurrency": 8, "best_total_tps": 7410.364484255659, "last_total_tps": 7410.364484255659} +{"timestamp": "2026-07-17T19:19:57+00:00", "engine": "sglang", "tp": 8, "dp": 1, "mark": "Y", "isl": 65536, "osl": 128, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 1, "saturation_concurrency": null, "stop_probe_concurrency": 1, "best_tps_concurrency": 1, "best_total_tps": 10520.43723343424, "last_total_tps": 10520.43723343424} +{"timestamp": "2026-07-17T19:35:18+00:00", "engine": "sglang", "tp": 8, "dp": 1, "mark": "Y", "isl": 65536, "osl": 256, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 1, "saturation_concurrency": null, "stop_probe_concurrency": 1, "best_tps_concurrency": 16, "best_total_tps": 10781.024288681343, "last_total_tps": 9117.650741306736} +{"timestamp": "2026-07-17T19:51:19+00:00", "engine": "sglang", "tp": 8, "dp": 1, "mark": "Y", "isl": 65536, "osl": 512, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 1, "saturation_concurrency": null, "stop_probe_concurrency": 1, "best_tps_concurrency": 16, "best_total_tps": 10590.779210797218, "last_total_tps": 7211.833554803717} +{"timestamp": "2026-07-17T20:08:22+00:00", "engine": "sglang", "tp": 8, "dp": 1, "mark": "Y", "isl": 65536, "osl": 1024, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_SLO_EXCEEDED", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 1, "saturation_concurrency": null, "stop_probe_concurrency": 1, "best_tps_concurrency": 16, "best_total_tps": 10070.271297180865, "last_total_tps": 5115.848526934653} +{"timestamp": "2026-07-17T20:41:40+00:00", "engine": "sglang", "tp": 8, "dp": 1, "mark": "Y", "isl": 131072, "osl": 128, "status": "TTFT_BOUNDARY", "stop_reason": "TTFT_GROUP_SKIP_THRESHOLD", "tested_points": 3, "search_cap": 512, "max_successful_concurrency": 1, "saturation_concurrency": null, "stop_probe_concurrency": 1, "best_tps_concurrency": 1, "best_total_tps": 10011.510313681734, "last_total_tps": 10011.510313681734} diff --git a/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/adaptive_summary.md b/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/adaptive_summary.md new file mode 100644 index 0000000..7647440 --- /dev/null +++ b/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/adaptive_summary.md @@ -0,0 +1,64 @@ +# Adaptive concurrency search summary + +| Engine | TP | DP | ISL | OSL | Stop | Saturation C | Best TPS C | Best Total TPS | Max successful C | +|---|---:|---:|---:|---:|---|---:|---:|---:|---:| +| sglang | 2 | 4 | 1024 | 128 | TPS_PLATEAU | 144 | 128 | 24218.533538377524 | 160 | +| sglang | 2 | 4 | 1024 | 256 | TPS_PLATEAU | 224 | 240 | 20149.40043367764 | 240 | +| sglang | 2 | 4 | 1024 | 512 | TTFT_SLO_EXCEEDED | None | 224 | 14510.556922778758 | 240 | +| sglang | 2 | 4 | 1024 | 1024 | TTFT_SLO_EXCEEDED | None | 224 | 10464.061773456211 | 240 | +| sglang | 2 | 4 | 1024 | 2048 | TTFT_SLO_EXCEEDED | None | 160 | 7165.920914246007 | 160 | +| sglang | 2 | 4 | 1024 | 4096 | TTFT_SLO_EXCEEDED | None | 224 | 6226.953488408162 | 224 | +| sglang | 2 | 4 | 4096 | 128 | TTFT_SLO_EXCEEDED | None | 80 | 41660.494982592325 | 96 | +| sglang | 2 | 4 | 4096 | 256 | TTFT_SLO_EXCEEDED | None | 80 | 31736.653246447207 | 96 | +| sglang | 2 | 4 | 4096 | 512 | TTFT_SLO_EXCEEDED | None | 80 | 21026.710283187298 | 96 | +| sglang | 2 | 4 | 4096 | 1024 | TTFT_SLO_EXCEEDED | None | 80 | 13798.009301581149 | 96 | +| sglang | 2 | 4 | 4096 | 2048 | TTFT_SLO_EXCEEDED | None | 80 | 8849.759539925572 | 96 | +| sglang | 2 | 4 | 4096 | 4096 | TTFT_SLO_EXCEEDED | None | 48 | 4957.290960868959 | 48 | +| sglang | 2 | 4 | 16384 | 128 | TTFT_SLO_BACKOFF_FOUND | None | 8 | 45151.84310219225 | 8 | +| sglang | 2 | 4 | 16384 | 256 | TTFT_SLO_EXCEEDED | None | 16 | 42533.99259206337 | 32 | +| sglang | 2 | 4 | 16384 | 512 | TTFT_SLO_BACKOFF_FOUND | None | 8 | 21072.54759075096 | 8 | +| sglang | 2 | 4 | 16384 | 1024 | TTFT_SLO_EXCEEDED | None | 32 | 18269.061756587642 | 32 | +| sglang | 2 | 4 | 16384 | 2048 | TTFT_SLO_BACKOFF_FOUND | None | 16 | 8010.507208814893 | 8 | +| sglang | 2 | 4 | 65536 | 128 | TTFT_GROUP_SKIP_THRESHOLD | None | 16 | 21161.91201514059 | 1 | +| sglang | 4 | 2 | 1024 | 128 | TTFT_SLO_EXCEEDED | None | 80 | 20064.847256749188 | 80 | +| sglang | 4 | 2 | 1024 | 256 | TTFT_SLO_EXCEEDED | None | 112 | 16998.193925507032 | 112 | +| sglang | 4 | 2 | 1024 | 512 | TTFT_SLO_EXCEEDED | None | 224 | 16290.664734334032 | 224 | +| sglang | 4 | 2 | 1024 | 1024 | TTFT_SLO_EXCEEDED | None | 224 | 11924.700934652748 | 224 | +| sglang | 4 | 2 | 1024 | 2048 | TTFT_SLO_EXCEEDED | None | 128 | 7347.710241657577 | 128 | +| sglang | 4 | 2 | 1024 | 4096 | TPS_PLATEAU | 144 | 160 | 5792.414649417691 | 160 | +| sglang | 4 | 2 | 4096 | 128 | TTFT_SLO_EXCEEDED | None | 80 | 62360.79085845758 | 80 | +| sglang | 4 | 2 | 4096 | 256 | TTFT_SLO_EXCEEDED | None | 80 | 48008.51166904608 | 96 | +| sglang | 4 | 2 | 4096 | 512 | TTFT_SLO_EXCEEDED | None | 96 | 33192.15058943144 | 112 | +| sglang | 4 | 2 | 4096 | 1024 | TTFT_SLO_EXCEEDED | None | 48 | 11401.702019271886 | 48 | +| sglang | 4 | 2 | 4096 | 2048 | TTFT_SLO_EXCEEDED | None | 96 | 11627.161961587157 | 112 | +| sglang | 4 | 2 | 4096 | 4096 | TTFT_SLO_EXCEEDED | None | 48 | 5341.490327065961 | 48 | +| sglang | 4 | 2 | 16384 | 128 | TTFT_SLO_BACKOFF_FOUND | None | 8 | 42435.47732274857 | 8 | +| sglang | 4 | 2 | 16384 | 256 | TTFT_SLO_EXCEEDED | None | 16 | 42184.2844698077 | 32 | +| sglang | 4 | 2 | 16384 | 512 | TTFT_SLO_BACKOFF_FOUND | None | 8 | 20315.213143648834 | 8 | +| sglang | 4 | 2 | 16384 | 1024 | TTFT_SLO_EXCEEDED | None | 16 | 19718.50327444501 | 32 | +| sglang | 4 | 2 | 16384 | 2048 | TTFT_SLO_BACKOFF_FOUND | None | 16 | 7595.656062798347 | 8 | +| sglang | 4 | 2 | 65536 | 128 | TTFT_GROUP_SKIP_THRESHOLD | None | 16 | 15952.971597773088 | 1 | +| sglang | 8 | 1 | 1024 | 128 | TTFT_SLO_EXCEEDED | None | 64 | 15612.537562083084 | 64 | +| sglang | 8 | 1 | 1024 | 256 | TTFT_SLO_EXCEEDED | None | 64 | 13972.196218473699 | 80 | +| sglang | 8 | 1 | 1024 | 512 | TTFT_SLO_EXCEEDED | None | 96 | 10187.39875273473 | 96 | +| sglang | 8 | 1 | 1024 | 1024 | TTFT_SLO_EXCEEDED | None | 112 | 8254.49886320328 | 112 | +| sglang | 8 | 1 | 1024 | 2048 | TTFT_SLO_EXCEEDED | None | 112 | 6580.543973399365 | 112 | +| sglang | 8 | 1 | 1024 | 4096 | TTFT_SLO_EXCEEDED | None | 112 | 5333.722873915772 | 112 | +| sglang | 8 | 1 | 4096 | 128 | TTFT_SLO_EXCEEDED | None | 32 | 32068.844335167778 | 48 | +| sglang | 8 | 1 | 4096 | 256 | TTFT_SLO_EXCEEDED | None | 48 | 38696.19023732795 | 64 | +| sglang | 8 | 1 | 4096 | 512 | TTFT_SLO_EXCEEDED | None | 48 | 22005.195656396023 | 64 | +| sglang | 8 | 1 | 4096 | 1024 | TTFT_SLO_BACKOFF_FOUND | None | 16 | 4866.203776874325 | 8 | +| sglang | 8 | 1 | 4096 | 2048 | TTFT_SLO_EXCEEDED | None | 32 | 5901.399976779881 | 32 | +| sglang | 8 | 1 | 4096 | 4096 | TTFT_SLO_EXCEEDED | None | 48 | 5507.291915274797 | 48 | +| sglang | 8 | 1 | 16384 | 128 | TTFT_SLO_BACKOFF_FOUND | None | 8 | 69448.53298640453 | 8 | +| sglang | 8 | 1 | 16384 | 256 | TTFT_SLO_EXCEEDED | None | 16 | 67210.7404108151 | 32 | +| sglang | 8 | 1 | 16384 | 512 | TTFT_SLO_BACKOFF_FOUND | None | 8 | 24462.75823518966 | 8 | +| sglang | 8 | 1 | 16384 | 1024 | TTFT_SLO_EXCEEDED | None | 16 | 21304.812891337828 | 32 | +| sglang | 8 | 1 | 16384 | 2048 | TTFT_SLO_BACKOFF_FOUND | None | 8 | 7410.364484255659 | 8 | +| sglang | 8 | 1 | 65536 | 128 | TTFT_SLO_EXCEEDED | None | 1 | 10520.43723343424 | 1 | +| sglang | 8 | 1 | 65536 | 256 | TTFT_SLO_EXCEEDED | None | 16 | 10781.024288681343 | 1 | +| sglang | 8 | 1 | 65536 | 512 | TTFT_SLO_EXCEEDED | None | 16 | 10590.779210797218 | 1 | +| sglang | 8 | 1 | 65536 | 1024 | TTFT_SLO_EXCEEDED | None | 16 | 10070.271297180865 | 1 | +| sglang | 8 | 1 | 131072 | 128 | TTFT_GROUP_SKIP_THRESHOLD | None | 1 | 10011.510313681734 | 1 | + +`Saturation C` is the first point in the final low-gain streak. `Best TPS C` is the tested point with the highest observed Total TPS. diff --git a/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/run_manifest.json b/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/run_manifest.json new file mode 100644 index 0000000..73d90d0 --- /dev/null +++ b/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/run_manifest.json @@ -0,0 +1,27 @@ +{ + "experiment": "dsv4_h20_sglang_tp_dp_matrix", + "engine": "sglang", + "run_id": "adaptive_20260717-023422", + "model": "/data1/hf_models/DeepSeek-V4-Flash", + "hardware": "8x NVIDIA H20 96GB", + "matrix": "/data1/yy/sskj/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/matrix.json", + "dataset": "random", + "tokenize_prompt": false, + "random_range_ratio": 1.0, + "search": { + "start_concurrency": 16, + "max_concurrency": 512, + "multiplier": 2, + "initial_backoff_concurrencies": [ + 8, + 1 + ], + "num_prompts_multiplier": 5, + "min_tps_gain_pct": 2.0, + "plateau_patience": 2, + "warmup_max_requests": 0, + "ttft_slo_ms": 4000.0, + "enable_ttft_slo_stop": 1, + "ttft_group_skip_ms": 8000.0 + } +} diff --git a/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/shapes.tsv b/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/shapes.tsv new file mode 100644 index 0000000..121a236 --- /dev/null +++ b/experiments/h20/dsv4_h20_sglang_tp_dp_matrix/adaptive_results/adaptive_20260717-023422/shapes.tsv @@ -0,0 +1,29 @@ +mark input_len output_len +Y 1024 128 +Y 1024 256 +Y 1024 512 +Y 1024 1024 +Y 1024 2048 +Y 1024 4096 +Y 4096 128 +Y 4096 256 +Y 4096 512 +Y 4096 1024 +Y 4096 2048 +Y 4096 4096 +Y 16384 128 +Y 16384 256 +Y 16384 512 +Y 16384 1024 +Y 16384 2048 +Y 65536 128 +Y 65536 256 +Y 65536 512 +Y 65536 1024 +Y 131072 128 +Y 131072 256 +Y 131072 512 +Y 262144 128 +Y 262144 256 +Y 524288 128 +Y 1048576 128