acceptodds
Under review as a conference paper at ICLR 2027

Generative Latent Optimization for 3D Floorplanning

Abstract

Floorplanning determines the positions and shapes of circuit blocks within a chip outline while minimizing interconnect length and satisfying geometric constraints such as non-overlap and boundary containment. 3D floorplanning extends this problem by adding cross-die block alignment, making the feasible layout space highly coupled and difficult to optimize. Existing approaches often use Reinforcement Learning for floorplanning problems which can require careful hyperparameter tuning and long training time. We instead introduce Latent Geometric Optimization (LGO), which learns a structured latent representation of complete floorplans and searches this representation after training. A Transformer VAE encodes block geometry and layout variables, an evolutionary optimizer searches the latent space, and the decoder maps the latent codes back to the geometric domain. Searching this learned layout manifold enables coordinated global changes within and across dies. On MCNC and GSRC 3D floorplanning benchmarks, our approach outperforms the best-performing baseline on 7 of the 8 tested benchmark instances, with a mean improvement of 7.5%, despite being trained on a relatively weak dataset. We further demonstrate that our model is able to effectively generalize to unseen circuits with unseen block counts. Results suggest that LGO's relative advantage grows as the number of relational constraints between objects increases.

Primary area:
optimization
Keywords:
geometric constraints, manifold learning, constraint complexity, latent space optimization, test-time optimization, conditional Transformer VAE, genetic algorithms

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_5AzfOpenReview ↗
Rating
2
Confidence
4
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper proposes Latent Geometric Optimization (LGO), a generative optimization framework for 3D floorplanning. Instead of directly optimizing block coordinates, LGO employs a Transformer-based variational autoencoder (VAE) to learn a latent representation of complete floorplans. The decoder integrates graph-aware attention and spatial conditioning maps to capture circuit connectivity and geometric constraints, while an evolutionary algorithm searches the learned latent space to optimize half-perimeter wirelength (HPWL) and cross-die alignment. Experiments on eight MCNC and GSRC benchmarks show that LGO outperforms the published FlexPlanner results on seven out of eight instances, achieving an average improvement of 7.5% in the combined objective. The paper also presents zero-shot generalization experiments, ablation studies, and additional constrained packing experiments.

Critical strengths

S1. A framework for generative modeling and latent-space optimization. The paper presents a framework that combines generative modeling with latent-space optimization for 3D floorplanning. By learning a compact representation of complete layouts, the proposed method enables optimization of multiple geometric variables in the latent space. Furthermore, the integration of graph-aware attention, spatial conditioning, and autoregressive decoding allows the model to incorporate circuit connectivity and geometric constraints during layout generation. S2. Promising experimental results and useful supplementary analysis. The proposed method achieves competitive HPWL results across several 3D floorplanning benchmarks, with an average improvement of 4.4% over the previous best results. The authors also provide zero-shot transfer experiments and component ablations. In addition, the constrained packing experiments offer useful insights into how relational constraints affect the relative effectiveness of latent-space optimization.

Critical weaknesses

W1. The practical significance of the alignment improvements is not sufficiently demonstrated. One of the main objectives of this work is to improve cross-die alignment. However, the FlexPlanner baseline already achieves a high average alignment score of 0.940, while LGO improves it to 0.962, corresponding to an absolute improvement of only 0.022. Moreover, LGO performs worse than FlexPlanner on certain benchmarks, such as ami49 (0.886 vs. 0.955) and n300 (0.915 vs. 0.965). Given that the alignment metric is bounded by 1, the practical significance of these improvements remains unclear. More importantly, the paper reports average alignment scores without sufficiently analyzing whether the required cross-die alignment constraints are actually satisfied. A high average alignment score does not necessarily imply that all required block pairs meet their minimum overlap requirements. Reporting the proportion of fully satisfied alignment constraints and the distribution of alignment violations would provide stronger evidence of the practical value of the proposed method. W2. The experiments do not sufficiently isolate the benefits of the learned latent representation from those of extensive evolutionary search. The central contribution of this paper is the optimization of complete floorplans in a learned latent space. However, LGO combines a generative representation with a substantial test-time evolutionary search process. The reported improvements over FlexPlanner may therefore arise from the learned latent representation, the additional search budget, or both. In particular, the paper does not compare LGO against a FlexPlanner baseline equipped with repeated sampling and best-of-N selection under matched computational budgets. Such a comparison would help determine whether the additional VAE and latent-space optimization are necessary to achieve the reported improvements. Similarly, comparing evolutionary search with random latent sampling under the same number of evaluations would help quantify the contribution of the evolutionary optimization strategy. Although the paper includes a continuous optimization baseline in the additional packing experiments, these results do not directly establish the benefits of latent-space search for the primary 3D floorplanning task. Consequently, the central methodological advantage of the proposed framework remains insufficiently validated.

Questions for authors

Q1. Given that FlexPlanner already achieves near-saturated alignment scores, can the authors further explain the practical significance of the additional alignment improvements? In particular, can the authors report the percentage of cross-die alignment pairs that fully satisfy their required overlap constraints, rather than only reporting average alignment scores? Q2. Can the authors compare LGO against a FlexPlanner baseline using repeated sampling and best-of-N selection under matched wall-clock budgets? This would help clarify whether the reported improvements primarily result from the learned latent representation or from the additional test-time search effort. Q3. Can the authors provide an ablation comparing evolutionary latent-space search with random latent sampling under the same number of decoded candidates? Such an experiment would help isolate the contribution of the evolutionary search strategy.

1 comment

We thank the reviewer for the detailed review and the questions. Numbers below refer to the revised version. Note: we will still change some of the formatting and might add some additional explanations to the revised version of the paper in the coming days.

W1 / Q1: Practical significance of the alignment improvements

Fully satisfied alignment pairs (Sec. 4.3, Table 5). We added the metric the reviewer asks for: the percentage of alignment pairs with aln(i, j) = 1, i.e. the smaller block is fully covered by its partner's projection. We compare LGO with our reproduced FlexPlanner agent, both optimizing the soft objective of Eq. 6. LGO fully satisfies more pairs on all eight circuits (mean 71.1% vs 37.7%), for example n200: 86.7% vs 23.9% and n300: 82.0% vs 39.3%. Because the objective only ranks candidates over a frozen decoder, we can also search directly for full alignment without retraining. This "strict" variant reaches 80–93% on every circuit (mean 82.0%) and lowers the soft objective by at most 0.063. The published FlexPlanner layouts are not available, so this metric can only be computed for our reproduced agent. We will also add a per-pair histogram of aln(i, j).

As the reviewer points out, an average alignment close to 1 does not mean that the constraints are met, and the two metrics above differ considerably. Since the average is bounded by 1, improvements should be read relative to the remaining room: going from 0.940 to 0.962 closes more than a third of it.

ami49 and n300 (App. E, Table 15). At the default weight (wA=0.5w_A = 0.5), LGO trades alignment for HPWL on these two circuits. With a higher alignment weight, chosen at search time without retraining, LGO exceeds FlexPlanner on both metrics:

  • ami49, wA=1w_A=1: alignment 0.983 (vs 0.955) with 3.9% lower HPWL.
  • n300, wA=2w_A=2: alignment 0.967 (vs 0.965) with 6.1% lower HPWL.

Averaged over all circuits, wA=1w_A=1 gives an alignment of 0.986 (vs 0.940), which closes about three quarters of the remaining gap, while mean HPWL is still 2.8% lower than FlexPlanner's (242,184 vs 249,054).

W2 / Q2 / Q3: Isolating the latent representation from the search budget

FlexPlanner with best-of-N at matched wall-clock (Q2; Sec. 4.1, Fig. 2). Figure 2 compares LGO with best-of-N stochastic sampling from FlexPlanner policies and with prior decoding, under the same wall-clock budget on n100, n200 and n300. LGO reaches a higher J on all three. On n100, FlexPlanner leads early before LGO overtakes it. The original FlexPlanner weights are not public, so these curves use our retrained agents (App. B).

Evolutionary search vs. random latent sampling (Q3; Sec. 4.4 "Without search", Table 7). With the same trained decoder, we sample latents independently from the prior and keep the best, under the wall-clock budget LGO uses for 200 rounds. The crossover/mutation step (Eq. 7) is negligible next to decoding, so random sampling gets at least as many decoded candidates as LGO. LGO wins on all eight circuits (mean J 0.5241 vs 0.4778).

Latent vs. direct search on the floorplanning task itself (Table 7, App. C.2). The reviewer notes that the continuous baseline only appeared in the packing experiments. We added a direct-search baseline for 3D floorplanning: the same genetic algorithm, operators, population and wall-clock budget, applied directly to block positions and footprints, with nearest-legal-position constraint handling. It is competitive up to 50 blocks but falls well behind from n100 upward (n300: 0.3121 vs 0.5310). The same search through a decoder with random weights reaches only 0.1661, so the decoder's masking alone does not explain the gains.

Finally, Table 14 shows that LGO improves on the best layout in its training data by 10.6% in HPWL and 9.0% in alignment on average.

Together, these results show that the improvements come from searching the learned latent space, not from the extra test-time budget alone.

We hope these additions address the reviewer's concerns. We are happy to clarify anything further.

Reviewer_NgaWOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper addresses 3D IC floorplanning, where block placement must minimize wirelength while satisfying geometric and cross-die alignment constraints. The authors propose Latent Geometric Optimization (LGO), which uses a Transformer VAE to learn a latent representation of complete floorplans and performs evolutionary search in the learned space. An autoregressive decoder incorporates spatial conditioning and graph-aware attention to generate layouts while accounting for placement constraints. Experiments on the MCNC and GSRC benchmarks show improvements over existing baselines, while additional evaluations examine transferability to unseen circuits and performance under different relational constraints.

Critical strengths
  1. The latent-search formulation is well motivated for strongly coupled geometric optimization. 3D floorplanning involves interacting objectives and constraints such as wirelength, non-overlap, boundary containment, aspect ratio, and cross-die alignment. Searching over a learned representation of complete layouts is, therefore, a reasonable alternative to directly modifying individual coordinates.

  2. The paper includes extensive experiments and reports strong performance on the main benchmarks.

Critical weaknesses

I am not particularly familiar with the IC floorplanning literature, so I may miss some domain-specific context.

  1. The contribution of latent-space optimization could be clarified further. LGO differs from the baselines in several respects, including autoregressive decoding, legality masking, constraint-aware spatial maps, graph-aware attention, and evolutionary search. It would be helpful to distinguish the benefits of searching in the latent space from those of these additional components.

  2. The manuscript would benefit from careful proofreading, as there appear to be several writing and editing issues. For instance, Lines 149–150 contain the sentence "The total Higher values of (aln(i,j)) indicate better satisfaction of the required overlap..", which appears to contain an editing artifact. Similarly, Lines 311–313 state, "Table 4 shows the ratio between the n100 model and our model trained jointly trained all benchmark instances."

Questions for authors
  1. Can the authors compare latent-space search with direct coordinate optimization using similar constraint handling and search budgets? I am not sure how much of the gain comes from the search space versus the decoder.

  2. Could the authors clarify whether the layouts in Tables 1–3 all satisfy the non-overlap and boundary constraints, including when the least-overlap fallback is used?

  3. For Table 4, is the reference model trained on all eight circuits or separately for each circuit? Section 4.2 and the caption seem to say different things.

  4. The introduction discusses several recent generative floorplanning and placement methods that are not included in the quantitative comparison. It would be helpful if the authors could clarify whether these methods can be fairly evaluated on the current 3D benchmarks, or explain the challenges involved in adapting them.

3 comments

We thank the reviewer for the questions. Numbers below refer to the revised version. Note: we will still change some of the formatting and might add some additional explanations to the revised version of the paper in the coming days.

Q1: Latent search vs. the other components, and direct coordinate optimization

The revision separates each component the reviewer lists:

  • Search space (latent vs. coordinates), Sec. 4.4 "Without decoder", Table 7, App. C.2. We run the same genetic algorithm directly on block positions and footprints, with the same operators, population size and wall-clock budget. Blocks are placed in the same order as our decoder, and an infeasible target is moved to the nearest legal position, which mirrors the decoder's legality masking. Direct search is competitive up to 50 blocks but falls well behind from n100 upward (n100: 0.3871 vs 0.5500; n300: 0.3121 vs 0.5310). This fits the direct genome growing linearly with the number of blocks while the latent dimension stays fixed.
  • Autoregressive decoding and legality masking, "Without learning". The same search through a decoder with identical architecture and masking but random weights reaches a mean J of 0.1661 vs 0.5241. Masking alone does not explain the gains.
  • Evolutionary search, "Without search". Sampling latents independently from the prior with the same trained decoder and budget gives a mean J of 0.4778 vs 0.5241. LGO is better on all eight circuits.
  • Spatial maps and graph-aware attention, Table 6. Removing any one input lowers J on n100 and on the unseen n50 circuit. The wire map, alignment map and graph attention matter most for n50, so they appear important for generalization.

So the gain comes from searching the learned latent space. Neither the decoder architecture nor the search procedure is sufficient on its own.

W2: Proofreading

Thank you for catching these. We fixed both sentences. The alignment definition (now L151–154) explains that aln(i, j) is the fraction of the smaller block covered by its partner's projection. Sec. 4.2 now states the reference model consistently with the Table 4 caption (see Q3). We are proofreading the full manuscript for the final revision.

Q2: Feasibility of the layouts in Tables 1–3

All LGO results in Tables 1–3 (and Tables 4–7) satisfy both the non-overlap and the die-boundary constraints. We now state this explicitly at the end of Sec. 3. When the least-overlap fallback is triggered, the decoded scene may contain overlap. Such scenes can remain in the population during the search, but the final solution is selected only from scenes without overlap or boundary violations. Likewise, every value in Fig. 2 from our methodology is computed from a valid scene. The baselines are not guaranteed to be overlap-free. Table 16 (App. F) reports their overlap. Several baselines have non-zero overlap, including published FlexPlanner on n10 (0.009).

Q3: Reference model for Table 4

The reference is a single model trained jointly on all eight circuits, the same model used in Tables 1–3. It is not trained per circuit. The zero-shot models are trained only on n100 (three seeds), and each ratio divides the zero-shot value by the joint model's value. The seven test circuits are unseen by the zero-shot models but seen by the joint model. Sec. 4.2 and the caption now both say this.

Q4: Recent generative floorplanning/placement methods

We added App. C.1 to explain why we do not compare against them. The baselines in Tables 1–3 were adapted to 3D floorplanning by the FlexPlanner authors (Zhong et al., 2024), so we could compare against their reported results. The generative methods (Liu et al., 2022; Zheng et al., 2025; Lee et al., 2025; Yoon et al., 2025; 2026) were designed for 2D placement. They place all objects at once in continuous coordinates. Adapting them would require:

  1. an output for soft-block aspect ratios;
  2. alignment pairs as extra relations in the input graph;
  3. most importantly, a differentiable objective that includes cross-die alignment. Most of these methods leave legalization to an external analytical placer, and Lee et al. (2025) only optimize wirelength and overlap.

Building (3) amounts to a new analytical 3D floorplanner, so the comparison would mostly test our own design choices rather than the original methods. App. C.1 also explains why alignment is hard for gradient-based methods. The projected-overlap term has zero gradient until partner blocks already overlap. Full containment also requires partner aspect ratios to fall in a narrow window, and the two must be coordinated before the term gives any signal. Autoregressive decoding avoids this because the partner's footprint is already fixed when the second block is placed. We state clearly that this is an expectation rather than a measured result.

We hope these additions address the reviewer's concerns. We are happy to clarify anything further.

Thank you for the detailed responses to my questions. Your responses have addressed most of my concerns. However, "recent generative floorplanning/placement methods were designed for 2D placement" appears to be overstated. For example, RulePlanner (ICML 2026) and Great3D (ASP-DAC 2026) are both recent works on 3D floorplanning. A discussion of these works and their comparability would be helpful.

Thank you for the follow-up and for pointing us to these two works. We have added a discussion of RulePlanner (Zhong et al., 2026) and Great3D (Ren et al., 2026) to App. C.1 ("Methods not included in the comparison", paragraph "Recent 3D floorplanning methods").

No code is available for either method. At the time of writing, neither RulePlanner nor Great3D has released an implementation, so we cannot run them on our benchmark setting. Reimplementing them from the papers would not give a reliable comparison either. Our experience with FlexPlanner shows this. Its trained weights are not public, so we retrained it from scratch with the exact code and hyperparameters from the paper, and our reproduction still falls well short of the published results (mean alignment 0.794 vs 0.940 in Table 2). A reimplementation of a method that we cannot check against its original code carries the same risk. This leaves the numbers reported in the papers, and those are not comparable to ours, for the reasons below.

RulePlanner (ICML 2026) extends FlexPlanner's masked reinforcement-learning formulation to a broader set of design rules, adding boundary, grouping and pre-placement constraints to the alignment, non-overlap, outline and shape constraints we consider. It uses the same MCNC and GSRC circuits, but every task in its evaluation activates at least one constraint that our formulation does not have, and its headline metrics (block-terminal distance and block-block adjacency length) have no counterpart in our setting. Their own re-run of FlexPlanner illustrates the difference in problem difficulty: on n100 it reaches alignment scores of 0.678 and 0.859 on their two main tasks, compared with the 0.961 that FlexPlanner reports under our formulation.

Great3D (ASP-DAC 2026) addresses a different formulation of 3D floorplanning:

  • the die each block goes on is decided by the method, whereas it is a fixed input in our setting;
  • the vertical requirement is expressed as face-to-face bonding density and die-area balance, rather than as a minimum projected overlap between designated block pairs;
  • overlap is allowed up to a tolerance, whereas we require zero overlap;
  • the objective combines wirelength with a cycles-per-instruction latency model.

We also note that our objective is applied during latent search rather than during training. Additional rules such as RulePlanner's could therefore in principle be added as extra terms in J, with the corresponding decoder masks, without retraining the model, whereas RulePlanner trains a separate policy for each rule set. It would be interesting to incoperate these formulations in future research, once code becomes available.

We hope this addresses the reviewer's remaining concern.

Reviewer_WTjvOpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

LGO trains a Transformer VAE on FlexPlanner-generated layouts and searches its latent space using an evolutionary optimizer. Its autoregressive decoder incorporates geometry, connectivity, and feasibility masks. Experiments on eight MCNC/GSRC circuits report improved HPWL and alignment, supplemented by transfer and packing experiments.

Critical strengths
  • The global latent representation and spatially conditioned decoder provide a plausible mechanism for coordinating coupled floorplanning decisions while checking local feasibility.

  • Tables 1–2 show improvements in both HPWL and alignment on five of eight circuits. Table 12 also shows gains over the best training layout under the selected objective, supporting optimization beyond reproducing examples.

Critical weaknesses
  • The benefit of latent search is not isolated. Table 5 ablates decoder inputs, but there is no comparison with independent prior sampling using the same decoder and candidate budget. LGO evaluates 256 initial candidates and 256 new candidates per round for 200 rounds, whereas Figure 2 compares its search trajectory with a fixed FlexPlanner result. The experiments therefore cannot distinguish the contribution of evolutionary latent search from that of the decoder and additional candidate evaluations.

  • The overall comparison does not resolve the HPWL–alignment tradeoff. Appendix A.2 replaces FlexPlanner's original normalization with constants chosen near its published final HPWL. Using these constants for both methods is internally consistent, but does not establish that they were optimized for equivalent tradeoffs. On ami49 and n300, lower HPWL accompanies alignment drops from 0.955 to 0.886 and 0.965 to 0.915. The headline 7.5% improvement in the composite score therefore needs support from comparisons at matched alignment levels or a sensitivity analysis of the scalarization.

Questions for authors
  1. How does latent search compare with independent VAE-prior sampling at the same number of decodes, and with repeated FlexPlanner sampling at matched wall-clock time?

  2. Do the gains persist under alternative HPWL normalizations and alignment weights, particularly when matching FlexPlanner's alignment on ami49 and n300?

1 comment

Thank you for the review, your time, and the questions. Both questions pointed to real gaps, and we revised the paper to address them. Numbers below refer to the revised version (the decoder-input ablation is now Table 6 and the best-training-sample comparison is now Table 14). Note: we will still change some of the formating and might add some additional explanations to the revised version of the paper in the coming days.

Q1: Isolating the contribution of latent search

Independent prior sampling with the same decoder (Sec. 4.4, Table 7). We added a "Without search" arm: using the same VAE checkpoint, we sample latents independently from N(0,I)\mathcal{N}(0, I), decode each, and keep the best, under the same wall-clock budget LGO uses for 200 rounds. Both arms share the decoder, and the crossover/mutation step (Eq. 7) is negligible next to decoding, so prior sampling gets at least as many decodes as LGO. Latent search wins on all eight circuits (mean J 0.5241 vs 0.4778), and the gap is largest on bigger circuits (n100: 0.5500 vs 0.4845; n200: 0.5097 vs 0.4572).

Two further arms separate the remaining components:

  • Without learning: the same search through a decoder with identical architecture but random weights. Feasibility masking alone does not explain the gains (mean J 0.1661).
  • Without decoder: the same GA run directly on block positions and footprints, with nearest-legal-position constraint handling (App. C.2). It is competitive up to 50 blocks but degrades from n100 upward (n300: 0.3121 vs 0.5310). This fits the direct genome growing linearly with block count while the latent dimension stays fixed.

The gain therefore comes from searching the learned latent space, not from the legalizing decoder, the extra evaluations, or the GA alone.

Repeated FlexPlanner sampling at matched wall-clock (Sec. 4.1, Fig. 2). We compare LGO against best-of-n stochastic sampling from FlexPlanner policies and against prior decoding, all under the same wall-clock budget, on n100, n200 and n300. LGO reaches a higher J on all three. On n100 FlexPlanner leads early, then LGO overtakes it. The FlexPlanner weights are not public, so these curves use our retrained agents (App. B). The published results stay as a separate comparison in Table 3.

Table 14 also shows that LGO beats the best training layout by 10.6% HPWL and 9.0% alignment on average, so the search does more than retrieve training examples.

Q2: The HPWL–alignment trade-off and the scalarization

We agree that one scalarization cannot settle the trade-off on its own. The revision therefore adds comparisons that do not depend on hpwlrefhpwl_{ref} or the weights.

  1. Pareto dominance at default weights. LGO has both lower HPWL and higher alignment than published FlexPlanner on five circuits (ami33, n10, n30, n100, n200), with zero overlap everywhere (Table 16). On these circuits LGO is better under any HPWL normalization and any positive weighting. The constants in Table 12 only affect ami49, n50 and n300.

  2. Matching FlexPlanner's alignment on ami49 and n300 (App. E, Table 15). We added a sweep over wA∈{0.5,1,2}w_A \in \{0.5, 1, 2\}. The objective only ranks candidates for a frozen decoder, so LGO is re-weighted at search time with no retraining. FlexPlanner would need to be retrained.

    • ami49, wA=1w_A=1: alignment 0.983 (vs 0.955) with 3.9% lower HPWL (732,677 vs 762,712).
    • n300, wA=2w_A=2: alignment 0.967 (vs 0.965) with 6.1% lower HPWL (431,140 vs 459,221).

    At matched or higher alignment, LGO keeps lower HPWL on both circuits. Combined with point 1, some LGO setting Pareto-dominates FlexPlanner on 7 of 8 circuits. The exception is n50: LGO's alignment is higher (0.989 vs 0.970) but its HPWL is 3.6% worse.

As a further check that does not depend on the scalarization, Sec. 4.3 reports the fraction of fully aligned pairs (strict coverage). Under the same objective, LGO beats our reproduced FlexPlanner agent on all eight circuits.

We hope these additions address the reviewer's concerns. We are happy to clarify anything further.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.