acceptodds
Under review as a conference paper at ICLR 2027

BiG-Flow: Program-Conditioned Discrete Flow Matching for High-Level Synthesis Pragma Design

Abstract

High-level synthesis (HLS) allows software developers to build FPGA accelerators from C/C++ kernels, but the quality of the resulting hardware depends on the inserted pragmas that take hardware expertise to choose, and every candidate design needs minutes to hours of synthesis. Learned HLS tools predict the quality of results (QoR) of a design and then search the design space of each new kernel with that predictor, which costs many predictions and synthesis runs per kernel and generalizes poorly to kernels outside the training set. We present BiG-Flow, a bidirectional graph flow-matching model conditioned on the program. One network generates pragma designs for a requested QoR and predicts the QoR of a given design, directly and without per-kernel search or fine-tuning. BiG-Flow encodes the control and data flow graph of a kernel once as context, generates designs with a discrete flow over the pragma sites of the kernel, predicts QoR with a continuous flow, and keeps every generated pragma within its legal values. We evaluate on an expanded HLSyn benchmark and 22 test kernels that are never seen in the training stage, with Vitis HLS as the oracle. BiG-Flow predicts latency with at least 17% lower error than state-of-the-art graph predictors. Given the QoR of a held-out design as the request, it returns a valid design within a factor of two of the requested latency for 58% of requests, against 41% for unconditional sampling. Asked for to speedups with 20 synthesis runs per kernel, it reaches a geometric-mean speedup of over the unoptimized design and up to on a single kernel, which is the speedup of random legal designs, that of the strongest LLM-based baseline, and that of AutoDSE given the same synthesis time. On one kernel it finds a design faster than the best design of a full AutoDSE search.

Primary area:
learning on graphs and other geometries & topologies
Keywords:
flow matching, high-level synthesis, graph neural network

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_vufGOpenReview ↗
Rating
2
Confidence
4
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

The paper proposes a way to assist HLS pragma insertions/selections using bidirectional flow matching.

Critical strengths

The paper has achieved good improvements over a problem that was important a couple of years ago. (See below.)

Critical weaknesses

The paper's main weakness is that the problem has grown beyond pragmas. The challenge now is rewriting the entire code for better optimization, not just tweaking pragmas.

The works cited by the papers are before 2026. The latest versions of frontier LLMs are offering such amazing capabilities. For example, would equipping LLM-DSE with the latest and greatest LLM yield better results?

Another issue: there don't seem to be any tests on the quality of the individual components of the framework. For example, how good is the QoR predictor?

I think addressing these two main concerns of mine would be good.

Questions for authors

What if more recent LLMs are used for, say, LLM-DSE (2025 vintage)? The recent ones have improved so significantly.

3 comments
AuthorsOpenReview ↗

Response to Reviewer vufG

The problem has grown beyond pragmas

We agree that LLMs are taking HLS beyond pragma tuning, and we surveyed this direction. It has made real progress. LLM pipelines now refactor C/C++ into synthesizable HLS code (C2HLSC, TODAES 2025; HLSRewriter, TODAES 2026), LLM agents solve the simple code-generation tasks of HLS-Eval (2025–2026), and agents restructure kernels for performance: HLSmith (2026) produces functionally correct designs for all 28 PolyBench kernels of HLSFactory and reaches up to 252× over the reference HLS kernels with frontier models, and Agent Factories (2026) reaches a mean 7× speedup with Claude Code agents.

Pragma design remains part of every one of these flows: C2HLSC ends with a separate pragma-identification stage, HLSRewriter with pragma-based PPA optimization, ChatHLS with a QoR-aware directive tuner, and HLSmith and Agent Factories set pipeline and unroll pragmas together with their code changes. It is also the part these systems solve by trial and error, for two reasons their authors report. First, they learn the QoR of a pragma choice only by synthesizing it: HLSmith diagnoses each new synthesis report before its next step, and Agent Factories synthesizes every variant of every sub-kernel, with a median of 5.8M tokens per kernel. Second, LLMs reason poorly about the hardware effect of pragmas: general-purpose LLMs "often fail to reason about the spatial architecture of the source code" and apply unrolling and memory banking inconsistently (HLSmith); fine-tuning on code text alone does not teach them "the architectural impact of pragma variations" (LIFT); and they "lack explicit program-structure awareness, limiting their ability to suggest effective pragmas" (PRISM).

BiG-Flow supplies exactly what is missing. It learns the mapping between pragma designs and QoR from synthesized designs, so for a kernel it has never seen, including code produced by these systems, it predicts the QoR of a pragma design with one network evaluation (per-kernel error 0.63 over three seeds, against 1.20 for HARP) and proposes complete designs for a QoR target before any synthesis. An agent can use it to propose complete pragma designs and estimate their QoR before synthesizing any of them. On the one comparison that isolates pragma design, LLM-DSE driven by the newest frontier models reaches at most 5.5× with 20 synthesis runs, against 8.6× for BiG-Flow (next answer). Pragma design also needs no functional verification, since pragmas never change what a kernel computes, which makes it the step that a learned model can automate at scale.

Newer LLMs for LLM-DSE

Appendix Table 22 already runs LLM-DSE online with GPT-4o, GPT-4.1, GPT-5 mini, and GPT-5. A larger model did not help there: GPT-5 reaches 2.9× and GPT-5 mini 5.2×, against 8.6× for BiG-Flow, the model of the paper and one of its three training seeds. We added the newest models available to us, released in September and October 2026, with the same protocol of 20 synthesis runs per kernel and online synthesis feedback. LLM-DSE sees the synthesis results of its earlier designs, while BiG-Flow chooses all 20 designs before any synthesis. The table reports BiG-Flow as the mean of its three training seeds:

LLM-DSE withSpeedup at 20 runs
GPT-5 mini (best model in the paper)5.2×
Claude Haiku 5.54.7×
Claude Sonnet 5.54.1×
Claude Opus 5.55.5×
Claude Opus 5.5, extended thinking5.5×
BiG-Flow, mean of three training seeds7.6×

The strongest model gains little over GPT-5 mini, and extended thinking adds nothing. With 20 runs, the agent can test only a few one-pragma changes per iteration, while BiG-Flow proposes complete designs for a kernel it has never seen.

Quality of the individual components

The QoR predictor is evaluated on its own in Section 5.2 and Table 1, on 22 kernels never seen in training. Over three seeds per model, its kernel-averaged error is 0.68 against 1.20 for HARP and 1.08 for HierarchicalMoE, and on a new split that holds out whole algorithm families it is 0.73 against 2.19 and 2.11 (responses to aM3x W2 and W4). Each other component has its own test: the program encoder in Table 9 and Figure 6, one network against two in Figure 5 and Table 13, legal decoding in Tables 13 and 14, and the generator in Section 5.3 and Table 10. The revision moves a summary of these ablations into the main text, using the added page.

Nice results but I suspect the gap will be narrowed fairly soon. And I still think that pragma alone doesn't cut it. Sorry but I am maintaining my score.

AuthorsOpenReview ↗

Response to Reviewer vufG's follow-up comment

Thank you for the follow-up. We agree that code rewriting is where much of the future gain lies, and we see BiG-Flow as a component of that future rather than an alternative to it. Recent work on agentic HLS supports this view. Ding et al. (arXiv 2609.21157) compare agents that design at RTL with agents that design through HLS: with two pragmas, an array partition and a pipeline, an agent obtains 256-way parallelism that its hand-written RTL reaches only at 32-way, and with HLS a weaker model reaches 0.95 times the speedup of a stronger one, against 0.40 times at RTL. Zhang et al. (arXiv 2602.01401) argue that HLS remains essential for agentic hardware design and name inadequate performance feedback as a key limitation of current HLS tools. Agents that rewrite code will therefore keep relying on pragmas, and on fast feedback about what each design achieves.

The rewriting works themselves report what limits them today. Every candidate needs synthesis or simulation: Agent Factories synthesizes every variant of every sub-kernel, with a median of 5.8M tokens per kernel, and Ding et al. note that a simulation close to the time limit leaves little room for iterative exploration and propose HLS latency estimates during optimization as future work. Pragmas remain hard to set by reasoning alone, as HLSmith reports that general-purpose LLMs apply unrolling and memory banking inconsistently. What these flows lack is a fast, learned model of how pragmas map to QoR on code that no model has seen, which is what BiG-Flow provides.

We see three concrete ways to plug BiG-Flow into a rewriting agent. First, as the pragma stage after each rewrite: a restructured kernel is a new program, which BiG-Flow handles without retraining, and it proposes complete pragma designs for a QoR target before any synthesis, in place of the trial-and-error pragma tuning that ends the flows of C2HLSC, HLSRewriter, and HLSmith. Second, as the fast evaluator that Ding et al. call for: BiG-Flow predicts the QoR of a design in one network evaluation, so the agent can rank its rewrite candidates by the best predicted QoR of their pragma designs and synthesize only the most promising ones. Third, as a training signal: the same prediction gives a rewriting agent a reward for every candidate without a synthesis run per step. Each of these removes synthesis runs from the loop of the agent, which is where its cost lies.

The formulation of BiG-Flow also points to a longer research path. A parameterized code transformation, such as a tile size, a partition factor, or a loop order, is one more discrete choice at a site of the program graph, which is the object BiG-Flow generates. Extending the discrete flow from pragma sites to transformation sites would let one program-conditioned model propose rewrites and pragmas together for an unseen kernel and predict their QoR, and we see this as the most promising direction for future work. Stronger language models and BiG-Flow therefore compound rather than compete: the better an agent proposes rewrites, the more rewritten kernels need pragma designs and QoR estimates, and BiG-Flow supplies them at the cost of one network evaluation instead of one synthesis run.

Reviewer_mfuDOpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper addresses a practical problem in FPGA development: given a C/C++ program, how to select pragmas (such as pipelining and loop unrolling) to speed up the generated FPGA program. The authors train a model capable of both predicting performance for a set of pragmas and generating pragmas according to desired performance targets. In practice, candidate configurations are generated first and then verified using an HLS tool. Under a budget of verifying up to 20 configurations per program, the method achieves a geometric mean speedup of 8.6× relative to the default configuration based on HLS tool clock cycle estimates.

Critical strengths
  1. Worthwhile problem: Trying every configuration in HLS can be time-consuming. Identifying a few quality configurations can save significant development time.

  2. Practical improvements: Under the same budget of 20 verifications, the approach outperforms random sampling, predictor-guided search, LLM baselines, and AutoDSE.

  3. Thorough experimentation: The authors verify results with HLS tools and report failures, timeouts, resource overruns, and per-program results, making it easy to determine where the method is effective.

Critical weaknesses
  1. Testing on "new programs" is not strict enough: Out of 22 test programs, 19 share similar algorithm types, scales, or implementations with the training set (some are identical except for constant values). This primarily demonstrates transferability to new variants of familiar algorithms rather than performance on genuinely unseen program types.

  2. Broad success criteria for "generation on request": A trial is considered successful as long as latency falls within 0.5× to 2.0× of the target and resources stay below the global hardware limit, without requiring compliance with user-specified resource budgets. Thus, the 58% success rate may not be directly interpreted as "58% of designs meet user requirements."

  3. Unstable contribution of program graphs: In Table 9, incorporating program graphs results in an average error of 0.613 across three runs, whereas omitting them yields a lower error of 0.536. The authors mainly highlight the best single run (0.446); repeated runs across variants are needed to confirm if this core design is genuinely effective.

  4. Unclear overhead trade-offs: The appendix reports that performance prediction for a batch takes ~15.8 seconds, compared to 0.162 seconds for a single forward prediction—a nearly 100× difference. While shared models save parameters, comparisons against fewer flow steps or simpler conditional generation methods are needed to prove the accuracy gains justify the computational cost.

  5. Discrepancy in synthesis counts: The main text states 11 programs were evaluated at 20 configurations each (220 total), matching Table 34. However, Table 32 lists a total of 304 runs across five speed targets. The authors should clarify if different candidate sets were used or if single designs were counted across multiple targets to verify the "equal verification budget" claim.

Questions for authors
  1. Please elaborate on the success rate and further justify the evaluation results.

  2. Did you consider comparing with HLSmith (https://arxiv.org/abs/2608.06791) ?

4 comments
AuthorsOpenReview ↗

Response to Reviewer mfuD - Part 1/2

W1. Strictness of "new programs"

Most test kernels of the original splits have a same-family kernel in training. Two new results test the stricter setting where they do not (details in our response to aM3x W4). Transferring the best designs of same-family training kernels reaches 3.5× against 8.6× for BiG-Flow, so BiG-Flow does more than reuse designs of related kernels. On a split that holds out four algorithm families entirely, BiG-Flow predicts latency with a kernel-averaged error of 0.73, against 2.19 for HARP and 2.11 for HierarchicalMoE (three seeds each), and the request still raises request-following success, from 0.33 without the request to 0.40, on 8 of the 11 kernels.

W2, Q1. What the 58% success rate means

A trial is considered successful as long as latency falls within 0.5× to 2.0× of the target … without requiring compliance with user-specified resource budgets.

The 58% is the share of requests for which the first design, generated without any search or synthesis, already meets the request when it is synthesized. Four points put it in context.

It is measured, not predicted. Each generated design is synthesized once with Vitis HLS. It counts only if it synthesizes within 30 minutes and fits the device (79% of the designs) and its latency is within 2× of the request (73% of the valid ones). Checking a design costs this one synthesis run, the same check that any candidate design needs.

It holds when the resources are part of the request. With the requested resources included, the first design meets the whole request for 53% of requests, against 32% for the same network without the request and 38% for a separately trained unconditional model. Against the same network, conditioning helps on 20 of the 22 kernels and hurts on none (splits 1 and 2; resources in units of the 80% budget):

Success criterionConditionalUnconditionalKernels better / worse
Latency within 2× (paper)0.580.4116 / 4
and every resource ≤ request + 0.10.530.3220 / 0
and every resource within ± 0.1 of the request0.360.1720 / 0
At most 2× slower and every resource ≤ request + 0.10.540.3619 / 1

No prior method answers a request with one design. To our knowledge, earlier methods search each kernel: predictor-guided searches (GNN-DSE, HARP, HierarchicalMoE) need many predictions and synthesis runs per kernel, and AutoDSE spends a median of 24.4 hours of synthesis on each kernel. The reference points we can measure are the same network without the request (0.41) and a separately trained unconditional model (0.47); the request adds 11 points over the stronger one.

It is practical. For a designer with a latency target and a resource budget, the first generated design is acceptable for about half of the requests at the cost of one synthesis run. When it is not, another sample costs one more run, with no search in between.

W3. Contribution of the program graph

Repeated runs support the design in Table 9. With three seeds per variant, each selected by the rule stated in the paper, the model with the pooled CDFG vector has a per-kernel error of 0.613 against 0.623 without it, and the alternative way to use the CDFG, aligning its nodes to individual pragma sites, raises the error to 0.84–0.93, above every seed of both variants. The 0.536 you cite for the model without the program graph is a single run evaluated at a checkpoint that the stated rule does not pick. At the checkpoint the rule picks, the same run is at 0.599, one of the three seeds behind the 0.623 above, and the revision corrects Table 9 and reports all seeds. Both variants are conditioned on the program: every pragma site carries features extracted from it (its loop, nesting depth, trip count, and iteration count), and the pooled vector adds a summary of the whole CDFG.

W4. Cost of 100-step prediction

Because the QoR path is a straight line, the flow can be integrated in one step: one evaluation of the network from the complete design costs the same as one pass of a separate predictor and gives similar accuracy (our response to aM3x Q2). The paper also compares the simpler alternatives: two separate networks for generation and prediction (Figure 5, Table 13), and searches guided by HARP and HierarchicalMoE, which reach 4.4× and 1.3× with the same 20 synthesis runs against 8.6× for BiG-Flow (Table 2).

AuthorsOpenReview ↗

Response to Reviewer mfuD - Part 2/2

W5. 304 versus 220 synthesis runs

Table 32 counts request–design pairs. The five requests' 160 proposals per kernel are deduplicated before 20 are drawn, and a design proposed under several requests is listed under each of them. The 220 synthesis runs (20 per kernel) are the distinct designs. No design was synthesized twice and no method received extra runs. The revision adds the number of distinct designs to Table 32 and corrects the sentence "about four of the 20 runs per request".

Q2. HLSmith

Thank you for the pointer. A head-to-head comparison is not possible: HLSmith's code is not public, and it appeared on arXiv in August 2026, seven weeks before the deadline, as concurrent work. It is also not an alternative to BiG-Flow but an earlier step of the same flow. HLSmith restructures C/C++ into HLS code with an agent that verifies each candidate by C and RTL simulation (28 PolyBench kernels, Vitis 2023.2, Alveo U280), and its optimizer still has to set the pipeline and unroll pragmas of the restructured code. A restructured kernel is a kernel no model has seen, the input BiG-Flow is built for, so the two can be chained: HLSmith rewrites the code and BiG-Flow designs its pragmas. The closest comparison we can run, LLM-DSE driven by the newest frontier models, is in our response to vufG, and BiG-Flow stays ahead of all of them. The revision discusses HLSmith in the related work.

I would only ask one more number: on a completely unfamiliar family of algorithms, if we consider the hard caps that engineers typically care about—latency not exceeding the target, and each resource not exceeding the budget—what is the success rate of the first design? Because I think this number clarifies the gap between "the model understanding the requirements" and "the generated design being directly usable.” I would like to keep my current score (weak acceptance).

AuthorsOpenReview ↗

Response to Reviewer mfuD's follow-up comment

Thank you for the question. On the 11 kernels of the four held-out algorithm families, each request gives a latency and a utilization for each of the four resources, LUT, FF, DSP, and BRAM, taken from the measured QoR of a held-out design. With both caps hard, latency at most the requested latency and every resource at most its requested utilization, the first design meets every cap for 4.8% of the 165 requests, against 1.8% for the same network without the request. With the request, 2.7 times as many first designs meet every cap.

These caps are strict for our requests, because each request is the measured QoR of an existing design of the kernel: meeting it means matching or beating that design in latency and in all four resources at once. Even the designs found by the AutoDSE search of the same kernel meet these caps for only 5.2% of requests, for a design drawn at random from them. These designs are expensive: they come from a full AutoDSE run, which in the fast-design study of the paper synthesizes a median of 156 designs in 24.4 hours per kernel. BiG-Flow is cheap: it has seen neither these kernels nor their families, runs no search, and spends one synthesis run on its first design. Its first designs therefore meet the caps about as often as designs that take a full AutoDSE run to find, at the cost of a single synthesis run instead of a full AutoDSE search.

If the latency cap keeps the factor of two of the paper's criterion, now only on the slow side, and every resource stays within its requested utilization, the first design meets all caps for 24% of requests, against 18% without the request and 14% for a design drawn at random from the AutoDSE designs of the kernel. Under this cap, the first designs of BiG-Flow are directly usable 1.7 times as often as the designs that a full AutoDSE run found for the same kernel.

We would add one remark on how this number should be read. BiG-Flow is a generative model that learns a distribution of designs for each request, and a single draw says little about a distribution. A designer therefore uses the model by drawing many designs and synthesizing them, and the paper measures what the draws buy: in the fast-design study, one synthesized draw reaches a geometric-mean speedup of 2.1×, the best of 5 draws 4.5×, and the best of 20 draws 8.6× (Figure 7 and Table 15), four times a single draw. Generative design models are used with many draws elsewhere too. HLS-Eval samples five designs per task for LLM-generated HLS code and reports pass@1 and pass@5. For each target bulk modulus, MatterGen (Zeni et al., Nature 2025) generates 8,192 candidate materials and filters them down to a few for synthesis, and it reports how many materials meeting a property target it finds for a given budget of DFT calculations. AutoDSE, the reference of the paper, synthesizes a median of 156 designs per kernel. In each case, a design method is judged by what its draws deliver within a budget of evaluations, not by a single draw, and by this measure BiG-Flow, with 20 synthesis runs, finds faster designs than every other method given the same budget. Whether BiG-Flow gives a designer a usable design is therefore decided by the best of the many designs drawn within the synthesis budget, not by the first one.

Reviewer_aM3xOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

The paper addresses pragma design for HLS kernels that are absent from training. It frames QoR prediction and QoR-conditioned pragma generation as the two conditionals of a program-conditioned joint p(T, Y | X) and trains one network for both. A HARP-style encoder pools the CDFG of each kernel into a single program vector. A six-layer graph transformer over the 4 to 22 pragma sites drives a discrete mixture-path flow (Gat et al. 2024, Campbell et al. 2024) over a shared 35-value vocabulary, and a small regression head drives a straight-line continuous flow over five QoR coordinates. The two flows share one clock through the Diagonal Flow Matching pairing s = 1 − t, and the QoR input is zeroed on a fraction p of samples so the head cannot read the label off its own input. Illegal pragma values are removed by an argmax projection at the final step. On Expanded HLSyn (75 kernels, 26,153 AutoDSE designs re-synthesized with Vitis HLS 2025.1 for an Alveo U200), the paper reports a kernel-averaged latency error 17% below HARP (0.549 vs 0.660), 58% vs 41% success at hitting a requested latency within a factor of two against the model’s own unconditional mode, and a geometric-mean speedup of 8.6× over the default design with 20 synthesis runs on the 11 test kernels of split 3. The comparison points are 6.2× for the first 20 AutoDSE runs, 5.1× for random legal designs, and 11.3× for a full AutoDSE run with a median of 156 runs and 24.4 hours.

Critical strengths

S1. Addresses an important problem.

S2. Thorough experimental section.

Critical weaknesses

W1. BiG-Flow is not a new graph flow matching method. The discrete path, marginal source distribution, cross-entropy objective and sampler come from Campbell et al. (2024) and DeFoG, the pragma transformer is the DiGress architecture, and the program encoder is HARP’s. Only 4 to 22 categorical labels are generated on a fixed graph, which is structurally the inverse folding setting already handled with discrete flows by MultiFlow.

W2. The prediction advantage over HARP is within seed variance. On split 3, the only split with multiple seeds, the pooled-vector model has a mean kernel error of 0.613 (range 0.446 to 0.817) and a mean design error of 0.474, against 0.649 and 0.400 for HARP.

W3. The benefit of QoR conditioning is not established. The request-following study compares against an unconditional mode trained on only about 5% of samples (p = 0.05). In the fast-design study, where p = 0.5 trains that mode properly, the paired per-kernel ratio of conditional to unconditional falls to about 1.15×, the unconditional sampler is ahead at 5 runs (5.07× vs 4.53×), and the median achieved speedup stays between 1.9× and 3.7× whether the request is 10× or 1000×.

W4. “Unseen kernel” mostly means unseen problem size. Nineteen of the 22 test kernels have a same-family training kernel, yet the paper includes no nearest-family baseline that transfers pragma ranks or retrieves matching designs, and no family-disjoint split, although the 536-kernel ForgeHLS corpus would allow one.

Questions for authors

Q1. Which elements of BiG-Flow do you consider methodologically new relative to DeFoG, MultiFlow and Diagonal Flow Matching? Why tie the two clocks instead of sampling independent times as in MultiFlow, which would put the prediction query inside the training distribution?

Q2. What is the prediction error if the QoR head is evaluated once at s = 0, without the 100-step integration? How many seeds stand behind the split-1 and split-2 results in Table 1?

Q3. Can you repeat the request-following study with a properly trained unconditional control (p = 0.5 or a separate model), and did you try classifier-free guidance with a weight above one?

Q4. Can you report the fast-design study on splits 1 and 2 with several seeds and bootstrap intervals over kernels, and with the 20 designs ranked by BiG-Flow’s own predicted QoR instead of chosen at random?

Q5. How does BiG-Flow compare with a nearest-family baseline, and how does it perform on a family-disjoint split or on the three test kernels whose family is absent from training?

6 comments
AuthorsOpenReview ↗

Response to Reviewer aM3x - Part 1/4

W1, Q1. What is new relative to DeFoG, MultiFlow, and Diagonal Flow Matching

BiG-Flow is not a new graph flow matching method … Which elements do you consider methodologically new …? Why tie the two clocks instead of sampling independent times as in MultiFlow?

An HLS engineer who receives a new kernel performs two tasks: estimating the QoR of a candidate pragma design, and finding a pragma design that meets a QoR target. Learned HLS tools have served the first task and solved the second by searching each kernel, with a predictor (GNN-DSE, HARP, HierarchicalMoE) or with synthesis in the loop (AutoDSE, and DID4HLS, which iteratively refits a generative model of pragma designs on each kernel). This costs many predictions and synthesis runs per kernel and transfers poorly beyond the training kernels. BiG-Flow models both tasks as the two directions of one program-conditioned network, which answers both for kernels never seen in training without per-kernel search or fine-tuning. To our knowledge, it is the first generative model that proposes pragma designs for a requested QoR on an unseen kernel directly from its program, and the first bidirectional flow-matching model over graphs. It differs from each of the three works in what it models and in what it can do.

  • Diagonal Flow Matching learns one invertible flow between a continuous design vector and its label, and predicts by inverting that flow. A pragma design is a set of categorical choices on a graph that changes from kernel to kernel, and a map onto finitely many designs cannot be inverted. BiG-Flow therefore generates with a discrete flow over the pragma sites of the kernel and predicts with a continuous flow over the QoR, both carried by one network, which also samples without a request when its QoR input is dropped.

  • DeFoG and other discrete graph flows generate graphs over a fixed vocabulary whose labels mean the same thing in every graph, and they do not predict properties. In BiG-Flow, every kernel brings its own pragma graph, legal options, and QoR range, and an unroll rank means a different factor in every kernel. One network serves all kernels by conditioning on the program and decoding every value within the legal set of the kernel, and the same network predicts the QoR of a design.

  • MultiFlow co-designs the structure and the sequence of a protein and samples both: the two modalities are parts of one object and are treated alike, with independent times. The two directions of BiG-Flow are not alike. A design determines its QoR, so prediction is many-to-one, and BiG-Flow reads a single value from a straight continuous flow. Many designs meet the same QoR, so generation is one-to-many, and BiG-Flow samples diverse designs with a discrete flow over pragma choices (90.6% of its proposals are distinct, Table 13). The pairing trains the two flows together in one network; MultiFlow's independent times, which we tested, bring no gain in either task (next paragraph). BiG-Flow also works on programs it has never seen, and every result we report is measured by synthesis.

The results test what this view makes possible: over three seeds, a per-kernel latency error 43% below HARP's; request following 11 points above a separately trained unconditional model; and with 20 synthesis runs, faster than the first 20 runs of AutoDSE on 18 of the 22 test kernels of splits 1 and 2 over three training seeds (W2, W3, and Q4 below). The choices that let one network serve all kernels are tested as well: the pairing of the two noise levels (next paragraph), legal decoding (Tables 13 and 14), and the form of program conditioning, where aligning CDFG nodes to pragma sites raises the kernel error to 0.84–0.93, against 0.61 for the pooled summary over three seeds (Table 9).

AuthorsOpenReview ↗

Response to Reviewer aM3x - Part 2/4

W1, Q1. What is new relative to DeFoG, MultiFlow, and Diagonal Flow Matching (continued)

Why pair the two noise levels. Prediction and generation are separate procedures at test time; the pairing only decides which states the network is trained on. Each training example draws one time tt, noises the design to level tt, and shows the QoR at level s=1−ts=1-t, the pairing of Diagonal Flow Matching: in every training example, the more of the design the network sees, the less of the QoR it sees. The two ends of this path are where the two procedures start: a complete design with no QoR, from which prediction reads the QoR, and a random design with the full request, from which generation builds a design. Your Q2 tests exactly this: evaluating the QoR head once at that starting state is about as accurate as integrating it for 100 steps (numbers under Q2). Drawing the two levels independently, as MultiFlow does, spreads training over combinations from which neither procedure starts. We trained that variant with the same recipe and the same seed as our model and ran each procedure from its own starting states. The variant's latency error on splits 1 and 2 is 0.54 per design and 0.67 per kernel, against 0.34 and 0.55 for our model; in request following the variant matches our model (success 0.58 for both) at a lower validity (0.73 against 0.79). Independent noise levels thus bring no gain in either task.

W2, Q2. Seeds behind Table 1, and one-step prediction

The prediction advantage over HARP is within seed variance … What is the prediction error if the QoR head is evaluated once at s = 0? How many seeds stand behind the split-1 and split-2 results?

Table 1 uses one training seed per model and split, for every method. We trained two more seeds of each predictor on splits 1 and 2, each selected on validation kernels as before. Mean ± standard deviation over the three seeds (log⁡10\log_{10} cycles, splits 1 and 2 averaged):

Per designPer kernel
HARP0.670 ± 0.3211.195 ± 0.668
HierarchicalMoE1.332 ± 0.6381.077 ± 0.243
BiG-Flow0.462 ± 0.1080.684 ± 0.126

The advantage holds across seeds: BiG-Flow's kernel-averaged error is 43% lower than HARP's and 36% lower than HierarchicalMoE's, and every BiG-Flow seed is below both baseline means. On split 3, the example in your review, HARP's three seeds average 1.017 per kernel and 0.645 per design, against 0.613 and 0.474 for BiG-Flow. HARP's large spread comes from a few unfamiliar kernels on which HARP errs by more than an order of magnitude in every seed.

One evaluation. Evaluated once at the starting state, the QoR head gives a per-kernel error of 0.63 (three seeds, splits 1 and 2), against 0.68 with the paper's 100-step integration. The two agree within seed variation, and on validation kernels the 100-step integration is slightly more accurate, which is why the paper keeps it. One evaluation is one Euler step of the same flow: the QoR path is a straight line (Ys=sYY_s = sY), so the velocity predicted at the starting state already points to the QoR, and prediction costs one forward pass when speed matters (0.17–0.35 s for 256 designs, against 15–31 s for 100 steps). The flow is what lets one network serve both tasks: the QoR state that prediction reads is the state through which a request conditions generation. Replacing it with a regressor beside a conditional generator is the two-network variant of the paper (Figure 5, Table 13): trained with the same seed, it is no more accurate in prediction (0.577 vs 0.549) or in request following (request error 0.427 vs 0.397), and it proposes fewer distinct designs (78.5% vs 90.6% unique).

AuthorsOpenReview ↗

Response to Reviewer aM3x - Part 3/4

W3, Q3. Is the benefit of conditioning established?

The request-following study compares against an unconditional mode trained on only about 5% of samples … Can you repeat it with a properly trained unconditional control, and did you try classifier-free guidance?

Yes. Against properly trained unconditional controls, the request still raises success by 11 points. We repeated the study with the same requests and seeds against a separate model trained only unconditionally (p = 1) and against a model trained with p = 0.5, whose two modes are trained equally often (splits 1 and 2, 583 requests). Success within budget also requires every resource to be at most 0.1 above its request, in units of the 80% budget:

SamplerSuccessSuccess within budget
Unconditional, p = 0.05 (paper's control)0.410.32
Separate unconditional model, p = 10.470.38
p = 0.5 model, unconditional0.420.33
p = 0.5 model, conditional0.530.45
p = 0.5 model, guidance w = 20.530.44
BiG-Flow (p = 0.05, paper)0.580.53

The strongest control, a model trained only unconditionally, reaches 0.47; BiG-Flow with the request is 11 points above it, 15 when the requested resources must also be met. Inside one p = 0.5 model, the request adds 11 points. The gain therefore comes from the request, not from a weak control. Classifier-free guidance with weight 2 gives the same success as weight 1, so a weight above one adds nothing.

Fast designs. Here the request is not a target to match. A request of 10× to 1000× sets how hard generation is pushed toward fast designs, and the goal is the fastest design within 20 synthesis runs. The median proposal therefore stays near 2× while the budget keeps the best one, as the paper states. Both samplers come from the same network, and both are strong: averaged over the three splits and three seeds, they reach 9.9× with the request and 9.5× without, against 8.7× for the first 20 runs of AutoDSE and 5.2× for random legal designs. Where the request is a precise target, as in request following above, the network follows it.

W4, Q5. "Unseen kernel" versus unseen algorithm family

Nineteen of the 22 test kernels have a same-family training kernel, yet the paper includes no nearest-family baseline … and no family-disjoint split.

The concern is whether BiG-Flow only replays designs of related training kernels. We tested this directly in two ways.

Nearest-family baseline. For each split-3 test kernel we take the valid designs of its same-family training kernels, rank them by their speedup on their own kernel, transfer each pragma site to the test kernel (unroll factors by their relative position in the list of legal factors, or by the closest legal value), and synthesize the first 20 distinct designs, the same budget as BiG-Flow. Transfer reaches 3.5× with either rule against 8.6× for BiG-Flow. On gemm-p_1200, the case study, BiG-Flow is 26× faster than the default design, while none of the 40 transferred designs finishes synthesis within the 30-minute limit of the protocol: the fastest designs of gemm-p_240 unroll the inner loops by factors that are affordable at size 240 and not at size 1200, so the transfer finds no design faster than the default. Transferring designs does not tell how far to scale them, which is what a model of the new kernel learns.

Family-disjoint split. We held out four algorithm families (adi, covariance with correlation, mvt, seidel; 11 kernels) from training and validation and retrained BiG-Flow, HARP, and HierarchicalMoE with three seeds each. On these kernels the gap to the graph predictors widens (mean ± standard deviation over the three seeds, log⁡10\log_{10} cycles):

Per designPer kernel
HARP1.197 ± 0.1152.187 ± 0.201
HierarchicalMoE1.217 ± 0.1912.105 ± 0.033
BiG-Flow0.692 ± 0.2700.729 ± 0.112

On these unseen families the request still raises request-following success from 0.33 without the request to 0.40, on 8 of the 11 kernels.

Kernels whose family is absent. On the three test kernels of splits 1 and 2 without a same-family training kernel, conditioning lowers the request-following error on all three (Appendix tables of splits 1 and 2), and the family-disjoint split above adds eleven more such kernels.

We did not use ForgeHLS for this test because its designs were synthesized with a different tool version and device, so using them would require running our front end and Vitis 2025.1 synthesis on every design.

Comments on the paper

1 comment
AuthorsOpenReview ↗

General Response to All Reviewers

We thank the reviewers for their careful reading. An HLS engineer who receives a new kernel performs two tasks: estimating the QoR of a candidate pragma design, and finding a pragma design that meets a QoR target. BiG-Flow models both tasks with one program-conditioned network that serves kernels never seen in training, without per-kernel search or fine-tuning. To our knowledge, it is the first generative model that proposes pragma designs for a requested QoR on an unseen kernel directly from its program, and the first bidirectional flow-matching model over graphs. The reviews raise three themes, and we ran new experiments for each. All numbers below come from Vitis HLS synthesis with the protocol of the paper.

  1. Transfer beyond algorithm families (aM3x, mfuD). A nearest-family baseline that transfers the fastest designs of the same-family training kernels reaches 3.5× where BiG-Flow reaches 8.6×. On gemm-p_1200, the case study of the paper, BiG-Flow finds a design 26× faster than the default design, and the nearest-family baseline finds no design faster than the default. On a new split that holds out four algorithm families entirely, BiG-Flow predicts latency with a kernel-averaged error of 0.73 against 2.19 for HARP and 2.11 for HierarchicalMoE (three seeds each), and the request still raises request-following success, from 0.33 without the request to 0.40.

  2. Robustness (aM3x, mfuD). With three training seeds per predictor, BiG-Flow's kernel-averaged latency error is 0.68 ± 0.13 against 1.20 ± 0.67 for HARP and 1.08 ± 0.24 for HierarchicalMoE. We repeated the fast-design study on the 22 test kernels of splits 1 and 2, with three training seeds per split. With 20 synthesis runs, BiG-Flow reaches 11.2× against 10.3× for the first 20 runs of AutoDSE and is faster on 18 of the 22 kernels. Against a separately trained unconditional model, conditioning still raises request-following success by 11 percentage points, and by 15 when the requested resources must also be met.

  3. Newer baselines (vufG, mfuD). LLM-DSE with the newest frontier models reaches 5.5× with Claude Opus 5.5 (with or without extended thinking), 4.1× with Sonnet 5.5, and 4.7× with Haiku 5.5 (released September and October 2026), against 8.6× for BiG-Flow (7.6× averaged over three training seeds) with the same 20 synthesis runs.

The revised paper contains all of these results; the main ones use the additional page. New results and discussions in the revised paper are highlighted in yellow.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.