acceptodds
Under review as a conference paper at ICLR 2027

CORA: Feasibility-Safe Learned Refinement for Virtual Network Function Migration and Reconfiguration

Abstract

Network function virtualization (NFV) delivers network services through service function chains (SFCs) composed of virtual network functions (VNFs). When a physical machine fails or becomes overloaded, the affected VNF instances must be migrated while satisfying CPU and memory capacities, link bandwidth, processing stability, end-to-end SFC delay, and utilization thresholds. Existing heuristic and learned constructors typically make one-shot deployment decisions, which may produce feasible yet locally inefficient placements or fail to fully remove the triggering overload. We introduce Constraint-aware Optimization with Reconfiguration Actions (CORA), a start-provider-agnostic learned post-optimizer for VNF reconfiguration. CORA first applies bounded repair and admits only complete deployments that become strictly feasible. It then represents the deployment as a heterogeneous PM–VNFI–SFC graph and searches over move and swap actions filtered by exact constraint checks. Every searched state remains feasible, while incumbent preservation guarantees that the returned deployment is no worse than the repaired start. On 30 frozen fat-tree-8 test instances spanning three migration regimes, CORA improves 20/29 (69.0%) paired feasible MSH-OR starts and 26/27 (96.3%) paired feasible MAT-GNN starts, with no paired degradation. The corresponding mean changes in the joint delay–load objective are -0.00253 and -0.01158, with both problem-seed bootstrap 95% confidence intervals lying strictly below zero.

Primary area:
optimization
Keywords:
network function virtualization, VNF migration, service function chaining, constrained combinatorial optimization, graph neural networks

Reviews

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

This paper presents CORA, a learned improvement method for virtual network function reconfiguration. Starting from a feasible deployment supplied by a bounded repair procedure, CORA uses a graph policy to rank move and swap actions. An exact checker filters out infeasible successors, and a bounded multi-start search returns the best feasible solution encountered. The policy is trained using a truncated policy-gradient objective and early ranking supervision. Experiments across three types of starting solutions show consistent paired improvements. The paper also includes classical-search comparisons, ablations, topology-transfer tests, and a small-instance conditional-optimality study.

Critical strengths
  1. The separation between construction, repair, and improvement is useful. CORA can refine deployments from different providers through a common interface. Exact successor checks preserve modeled feasibility, and keeping the best incumbent prevents the returned solution from getting worse than the repaired start. This is a sensible design for constrained optimization.
  2. The paired evaluation is carefully handled. The authors compare solutions from identical repaired starts, aggregate policy replicas within problem instances, and bootstrap over problem seeds. They also report failed starts separately and include both evaluation-matched and time-matched comparisons. The consistent gains across three start classes support the claim that the refinement stage is reusable.
Critical weaknesses
  1. The added value of the learning components is not fully isolated, and ablation experiments are needed.
  2. The experiments cover a fairly controlled version of the application.The generator makes queue stability placement-invariant, relaxes deadlines when needed, and scales bandwidth demands down to keep initial link utilization below a specified level. Requests also share an ingress and egress, and SFC–VNFI assignments remain fixed. These assumptions are clearly disclosed, but they limit how much the experiments tell us about settings where queueing, bandwidth, and delay are simultaneously tight. The largest family has 120 SFCs, and each transfer family has only five problem seeds. More evidence is needed to establish the method’s practical value beyond the tested synthetic workload.
Questions for authors
  1. What is the exact relationship between the four incremental features and the one-step objective change? How expensive would it be to rank candidates directly using the same incremental calculations?
  2. Under the same features, supervision budget, and search procedure, how do a feature-only MLP and a ranking-only policy perform?
  3. How often do CPU, memory, bandwidth, and delay constraints each reject candidate actions? Does CORA retain its advantage when bandwidth and delay are tighter?
  4. Could you provide the instance generator, incremental checker, evaluation implementation, and model weights so that the main comparisons can be independently reproduced?
2 comments
AuthorsOpenReview ↗

We add controlled learning-component ablations, tighter-constraint and expanded-seed tests, audit the incremental objective calculations and constraint rejections, and specify the materials needed to reproduce

We thank the reviewer. We added matched ablations and harder tests.

W1&Q2.

Table 1. Component ablation (lower ΔJ is better).

VariantMean ΔJ ↓Full CORA's extra reduction [95% CI]
Full CORA-0.01989—
Ranking-only GNN-0.01862+0.00129 [0.00062,0.00209]
RL-only GNN-0.00401+0.01589 [0.00766,0.02526]
Feature MLP-0.01959+0.00030 [-0.00042,0.00119]

Table 2. Full training versus ranking-only training (95% CI).

ComparisonExtra reduction
Full vs ranking-only+0.00093 [0.00048,0.00143]

Table 3. Full CORA versus ranking-only GNN by scale.

ScaleStrict/attemptedFull ΔJRanking-only ΔJFull advantage [95% CI]
30 SFC10/10-0.01018-0.00948+0.00070 [+0.00015,+0.00136]
60 SFC9/10-0.00467-0.00350+0.00117 [+0.00037,+0.00210]
120 SFC5/10-0.00694-0.00598+0.00097 [-0.00016,+0.00215]
Overall24/30-0.00744-0.00651+0.00093 [+0.00048,+0.00143]

Ranking supervision stabilizes candidate ranking; RL uses trajectories to improve the multi-step result. Full CORA gains 0.00129 [0.00062,0.00209] over ranking-only and 0.01589 [0.00766,0.02526] over RL-only. Feature MLP judges immediate change; graph encoding adds physical/service context for actions with similar local features but different later effects. They are complementary.

W2.

Table 4. CORA under tighter resources (95% CIs).

ConditionStrict/attemptedCORA extra improvement [95% CI]
Tight delay8/10+0.00770 [0.00359,0.01204]
Tight bandwidth10/10+0.00469 [0.00198,0.00780]
Joint pressure, distributed endpoints7/10+0.01720 [0.00319,0.03268]

Topology/scale tests use ten seeds per condition. ΔJ is change from CORA's strict start, not a baseline contrast:

Table 5. Topology/scale tests (95% CIs).

TopologyStrict/attemptedHostsSFCsMean ΔJ [95% CI]Online s
Fat-tree-48/101624-0.04680 [-0.06143,-0.03100]0.727
VL210/101624-0.02919 [-0.03997,-0.01984]1.591
BCube10/101624-0.13841 [-0.18338,-0.09671]1.738
Fat-tree-89/1012860-0.01122 [-0.01904,-0.00601]3.413
Fat-tree-8 large10/10128120-0.00734 [-0.01171,-0.00325]5.164
Fat-tree-168/101,024120-0.00520 [-0.00833,-0.00285]21.602

These results show that CORA improves the same strictly feasible starts under bandwidth, latency, joint constraints, and traffic disturbances, rather than relying on lenient resources. We thank the reviewers for noting the limits of synthetic evaluation. Production data covering physical topology, VNF resources, service-chain demands, and migration records are difficult to obtain. For the deployment-refinement problem studied here, synthetic instances approximate relevant network conditions while enabling controlled resource stress and reproducible paired comparisons. Real networks may vary in capacity, traffic, constraints, and objectives; CORA’s separation of candidate generation, feasibility checking, and objective evaluation facilitates adaptation to these settings. We also test stricter resource conditions and more prespecified problem seeds. Of course,platform-specific performance still requires validation with real data.

Q1. We audited four increments—CPU, memory, and link variance plus affected-SFC delay—against full recomputation on 23 strict starts; they recover one-step change to numerical precision. Analytic incremental greedy shares starts, legal actions, checks, budget, and information. It wins on some tiny-budget starts, but CORA gains as budget and scale increase by selecting actions with later potential. A full analytic scan takes 154.8 ms versus 72.2 ms to score an already formed CORA batch; scopes differ, so end-to-end efficiency is assessed separately.

Q3. We added exact per-action rejection attribution.

Table 6. Rejection rates and CORA gains (95% CIs).

ConditionStrict/attemptedCPUMemoryBandwidthDelayCORA extra improvement [95% CI]
Control5/51.18%0.66%0%53.41%+0.00994 [0.00345,0.01868]
Tight delay4/518.88%1.35%0%67.11%+0.01157 [0.00612,0.01702]
Tight bandwidth5/51.78%0.52%6.36%50.44%+0.00476 [0.00129,0.00940]
Joint pressure4/521.02%20.70%2.59%65.29%+0.01597 [0.00072,0.03991]

Across four pressure settings, CORA retains positive paired gains over the same-information baseline, including tight bandwidth and joint pressure.

Q4. We thank the reviewer for emphasizing reproducibility. We have organized a complete package and will provide it anonymously, including start construction, bridge repair, candidate generation, exact checks, and the learned policy.

AuthorsOpenReview ↗

Looking forward to your reply

Dear Reviewer QmEo,

We value your positive feedbacks and constructive suggestions for our paper and sincerely appreciate your effort in reviewing it. We hope we have effectively addressed all the concerns raised. As the end of the discussion is approaching, we are wondering if there are any additional potential clarifications or suggestions that you think would help us improve this manuscript.

Thank you again for your dedicated review and invaluable insights.

Kind regards,

Paper CORA(id:45326) Authors

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

This paper proposes CORA, a learning-based refinement framework that integrates graph neural networks (GNNs) and reinforcement learning (RL) to further optimize existing virtual network function (VNF) migration solutions. CORA aims to reduce service delay and improve load balancing while satisfying network resource and quality-of-service constraints. The authors evaluate CORA with different initial solution providers and network topologies. Experimental results demonstrate that CORA can effectively improve the objective values of existing deployment solutions, although its runtime performance does not consistently outperform conventional local search methods.

Critical strengths
  • The paper addresses the residual optimization opportunities that may remain after existing VNF migration algorithms generate feasible deployment solutions. CORA provides a reusable learning-based refinement framework that can be applied to different types of initial solution providers, including heuristic, evolutionary, and learning-based approaches. By incorporating exact feasibility checks and best-incumbent retention, CORA preserves the modeled resource and quality-of-service constraints while ensuring that the final solution is no worse than the repaired feasible initial solution. This design offers practical value for improving existing VNF migration solutions.
  • The experimental evaluation is relatively comprehensive and examines the effectiveness of CORA from multiple perspectives. The authors consider three different initial solution providers and various VNF/SFC scales. They further conduct comparisons with conventional local search methods, ablation studies, cross-topology transfer experiments, and optimality verification on small-scale instances. The results demonstrate that CORA can further improve the optimization objective for most test instances with feasible initial solutions, indicating its effectiveness and a certain degree of generalization capability.
Critical weaknesses
  • CORA primarily integrates existing techniques, including graph neural networks, policy-gradient reinforcement learning, Move–Swap local search, multi-start exploration, and feasibility masking. Although these components are adapted to the VNF migration problem, the proposed framework does not appear to introduce a fundamentally new learning mechanism or search strategy beyond existing learned improvement heuristics. Moreover, its feasibility and non-degradation guarantees mainly rely on conventional exact constraint checking and best-incumbent retention, offering limited theoretical novelty. The authors should more clearly distinguish the essential methodological contributions of CORA from existing learning-based combinatorial optimization approaches.
  • Although CORA outperforms conventional local search methods under the same number of complete objective evaluations, its advantages become less consistent under equal CPU time budgets. In some cases, CORA even performs worse than conventional search methods, suggesting that the additional overhead of neural network inference and candidate action evaluation may offset its optimization benefits. Furthermore, the experiments are primarily conducted on synthetic network instances, without validation in realistic VNF migration environments. Important practical factors, such as migration duration, service disruption, and control overhead, are not sufficiently considered. Therefore, the current evaluation does not adequately establish the overall advantages of CORA in practical dynamic network environments.
Questions for authors
  1. CORA combines existing techniques, including GNNs, reinforcement learning, and Move–Swap local search. Compared with existing learned improvement heuristics, what algorithmic designs are specifically novel to the VNF migration problem? Could the authors further clarify the core methodological contributions beyond adapting established techniques to a different optimization scenario?
  2. The ablation results do not demonstrate a significant performance advantage of the dual-stream graph encoder over the physical-only or service-only encoders. What is the necessity of jointly modeling physical topology and service-chain relationships? Could the authors provide further analysis of how these two types of graph relationships contribute to migration decisions and optimization performance?
  3. CORA relies on feasible deployment solutions generated by existing algorithms, and its improvement potential may strongly depend on the quality of these initial solutions. Could the authors further investigate the relationship between initial solution quality and the improvement achieved by CORA? In particular, when the initial solution is already close to optimal, can CORA still provide sufficient benefits to justify its additional computational overhead? Moreover, since the RL-based policy requires additional training data and potentially substantial training time, how do these offline costs affect the overall cost-effectiveness of the proposed framework?
2 comments
AuthorsOpenReview ↗

We clarify CORA’s VNF-specific state–action modeling and training design, analyze the distinct roles of physical and service-chain relations, and address runtime, initial-solution quality, offline cost, and deployment limitations.

We thank the reviewer for examining novelty.

W1&Q1.

Table 1. Component ablation (lower ΔJ is better).

VariantMean ΔJ ↓Full CORA's extra reduction [95% CI]
Full CORA-0.01989Reference
Ranking-only GNN-0.018620.00129 [0.00062,0.00209]
RL-only GNN-0.004010.01589 [0.00766,0.02526]
Action-feature MLP-0.019590.00030 [-0.00042,0.00119]

Table 2. Full versus ranking-only training.

ComparisonExtra reduction [95% CI]
Full vs ranking-only+0.00093 [0.00048,0.00143]

Existing VNF graph learning mainly concerns initial placement, SFC deployment, or fault tolerance. CORA asks how a move/swap changes loads, links, paths, and delay in a complete deployment, and whether it merits further search. Physical/service relations and action increments enable VNF-specific action-level ranking, not merely drawing graph nodes.

CORA does not simply apply policy gradient. Legal actions change and returns are sparse; exact checks restrict actions. Exact-successor rankings and hard negatives provide early supervision, gradually yielding to truncated policy gradient for multi-step search. Returns reflect current improvement and incumbent updates.

W2. Equal-online-time comparisons include candidates, features, graph inference, exact checks, and search control. Positive values favor CORA.

Table 3. Equal-online-time comparisons [95% CIs].

Start (paired problems)vs First improvementvs Best improvementvs Tabu search
MSH-OR (14)+0.00160 [0.00058,0.00281]+0.00036 [-0.00036,0.00120]-0.00003 [-0.00054,0.00042]
IHGE (13)-0.00331 [-0.00611,-0.00084]-0.00351 [-0.00573,-0.00156]-0.00365 [-0.00582,-0.00174]
MAT-GNN (12)+0.00020 [-0.00164,0.00209]-0.00079 [-0.00302,0.00126]+0.00007 [-0.00168,0.00172]

Recurring, coupled reconfiguration suits CORA; short one-off tasks may favor classical search. Complete real topology, VNF, SFC, and migration data are scarce. Synthetic instances approximate real conditions to some extent, control pressure, and enable reproducible paired tests. Separate generation, checking, and evaluation permit adaptation to changed parameters. We test stricter settings; platforms still need real-data validation. Migration duration and service disruption concern execution, whereas this study focuses on deployment optimization.

Table 4. Resource pressure vs feature-prior greedy [95% CIs].

ConditionFeasible/attemptedCORA ΔJFeature-prior ΔJExtra reduction
Control10/10-0.00989-0.002310.00758 [0.00332,0.01290]
Tight delay8/10-0.01111-0.003410.00770 [0.00359,0.01204]
Tight bandwidth10/10-0.00638-0.001690.00469 [0.00198,0.00780]
Joint pressure7/10-0.02070-0.003500.01720 [0.00319,0.03268]

Table 5. Bandwidth-perturbation tests [95% CIs].

StartFeasible/attemptedCORA ΔJExtra reduction
MSH-OR12/12-0.03440+0.02986 [0.02189,0.03779]
IHGE3/12-0.06071+0.04255 [0.01561,0.08214]
MAT-GNN9/12-0.05832+0.04715 [0.02092,0.07671]

These tests show gains under tight bandwidth/delay, joint pressure, and traffic perturbation. Migration duration and disruption concern operation.

Q2. Physical and service graphs are complementary. The former captures CPU/memory, link contention, bandwidth, and path cost; the latter captures VNF neighbors, SFC sharing, communication paths, and end-to-end delay. A resource-rich host may detour a chain; a closer host may create a bottleneck. Both inform feasibility, gain, and later actions.

Q3.

Table 6. Training time and amortization.

Model or usesSeconds/replicaThree-replica total or amortized seconds/call
Full CORA1,026.73,080.2
Ranking-only GNN1,287.43,862.2
Feature MLP812.62,437.9
Full CORA / 100 uses—10.2673
Full CORA / 1,000 uses—1.0267
Full CORA / 10,000 uses—0.1027

We assess four aspects:

  1. Start quality: Similar objectives can conceal different bottlenecks, detours, and legal actions. CORA searches remaining opportunities, not only high-objective starts.
  2. Near-optimal starts: Three policies reached the conditional optimum in small fat-tree-4 audits. If a start attained it, incumbent-safe updates retained the plan; CORA avoids degradation and should stop when little remains to gain.
  3. Applicability: CORA improves feasible MSH-OR, IHGE, and MAT-GNN starts. Coupled moves/swaps can address imbalance, contention, and detours without reconstructing the deployment.
  4. Offline cost: Training averages 1,026.7 seconds per replica, plus online solving. Classical search may be cheaper for urgent one-off tasks; recurring similar requests can amortize training. CORA aims for repeated high-quality feasible deployments, not minimum single-call latency.
AuthorsOpenReview ↗

Looking forward to your reply

Dear Reviewer UeFA,

We value your positive feedbacks and constructive suggestions for our paper and sincerely appreciate your effort in reviewing it. We hope we have effectively addressed all the concerns raised. As the end of the discussion is approaching, we are wondering if there are any additional potential clarifications or suggestions that you think would help us improve this manuscript.

Thank you again for your dedicated review and invaluable insights.

Kind regards,

Paper CORA(id:45326) Authors

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

The paper introduces CORA, a learning-based framework for virtual network function migration. In this problem, network services are provided by chains of software functions hosted on physical machines. When resource overload requires reconfiguration, the goal is to relocate selected functions to improve service delay and resource-load balance while satisfying CPU, memory, bandwidth, and end-to-end delay constraints.

Starting from a feasible configuration, CORA uses a learned graph-based policy to rank move and swap actions. A move relocates a virtual network function to another physical machine, while a swap exchanges the hosts of two functions. Explicit constraint checks ensure that accepted actions maintain feasibility, and the method outputs the best feasible incumbent. Experiments on synthetic network instances demonstrate improvements from several types of starting solutions. Comparisons show improvements over classical local search under equal objective-evaluation budgets, while equal-runtime results are mixed.

Critical strengths
  • The paper addresses a practical optimization problem with several interacting constraints. CORA separates learned action selection from explicit feasibility checking, providing a clean and useful design.

  • The experiments are extensive and include several types of starting configurations and classical search baselines.

Critical weaknesses
  • CORA’s practical advantage over classical methods remains unclear. It performs better under a fixed objective-evaluation budget that excludes some candidate computations, while the equal-runtime comparisons, which include these costs, provide mixed results.

  • The contribution of the learning components does not seem fully isolated. For example, the experiments do not establish the benefit of reinforcement learning over ranking-only training, or of the graph representation over a simpler learning model using the action features.

  • The experimental evaluation focuses exclusively on synthetic instances. This limits the evidence of practical effectiveness under real-world operating conditions.

Questions for authors
  • Could classical local search benefit from the same incremental objective information computed for CORA’s candidate features? If so, how would this affect the comparison?

  • Given the mixed equal-runtime results, under what conditions should CORA be preferred over classical local search?

  • What additional benefit comes from reinforcement learning beyond ranking-only training, and from the graph encoder beyond a simpler model using the action features?

5 comments
AuthorsOpenReview ↗

We clarify the difference between evaluation-matched and online time-matched comparisons, add a strong incremental-greedy baseline and component ablations, and state where CORA’s multi-step refinement is beneficial—and where classical search remains preferable

[I] Weaknesses

W1&Q2. We thank the reviewer for distinguishing evaluation count from actual cost. Fixed complete-objective evaluations measure decision quality under limited search opportunities. Equal online time includes candidate generation, features, graph encoding, inference, exact checks, and search control from the same feasible starts; offline training is separate.

Table 1. CORA over Best improvement at equal evaluations (paired 95% CIs).

Start3 evaluations25 evaluations
MSH-OR+0.00393 [0.00195, 0.00716]+0.00567 [0.00269, 0.00936]
IHGE+0.01351 [0.00778, 0.01988]+0.01965 [0.00732, 0.03291]
MAT-GNN+0.01364 [0.00930, 0.01782]+0.01604 [0.00594, 0.02844]

This supports CORA's decisions when complete evaluations are limited.

Table 2. CORA over classical search at equal online time (95% CIs).

Startvs First improvementvs Best improvementvs Tabu search
MSH-OR+0.00160 [0.00058, 0.00281]+0.00036 [-0.00036, 0.00120]-0.00003 [-0.00054, 0.00042]
IHGE-0.00331 [-0.00611, -0.00084]-0.00351 [-0.00573, -0.00156]-0.00365 [-0.00582, -0.00174]
MAT-GNN+0.00020 [-0.00164, 0.00209]-0.00079 [-0.00302, 0.00126]+0.00007 [-0.00168, 0.00172]

These results define the applicability boundary. CORA has a detectable online gain over First improvement from MSH-OR starts and relative gains from MAT-GNN starts; classical search is better from IHGE starts. CORA better suits coupled reconfiguration, moderate or larger budgets, recurring requests, and quality-oriented tasks. Short, small, one-off tasks may favor classical search; repeated use may amortize training.

W2&Q3.

Table 3. Component ablation (lower ΔJ is better; positive favors CORA).

VariantMean ΔJ ↓Full CORA's additional reduction [95% CI]
Full CORA-0.01989—
Ranking-only GNN-0.01862+0.00129 [0.00062, 0.00209]
RL-only GNN-0.00401+0.01589 [0.00766, 0.02526]
Feature MLP-0.01959+0.00030 [-0.00042, 0.00119]

Table 4. Full CORA versus ranking-only GNN by scale.

ScaleStrict/attemptedFull ΔJRanking-only ΔJFull advantage [95% CI]
30 SFC10/10-0.01018-0.00948+0.00070 [+0.00015, +0.00136]
60 SFC9/10-0.00467-0.00350+0.00117 [+0.00037, +0.00210]
120 SFC5/10-0.00694-0.00598+0.00097 [-0.00016, +0.00215]
Overall24/30-0.00744-0.00651+0.00093 [+0.00048, +0.00143]

Ranking supervision stabilizes candidate ranking; RL uses trajectory returns to optimize the multi-step outcome. Full CORA improves over ranking-only and RL-only training by 0.00129 [0.00062, 0.00209] and 0.01589 [0.00766, 0.02526], respectively. The feature MLP judges immediate changes; graph encoding adds physical and service context to distinguish actions with similar local features but different future effects. The two are complementary.

W3. We thank the reviewer. Real data jointly covering topology, VNF resources, SFC demands, and migrations are hard to obtain. For placement post-optimization, synthetic data approximate real conditions to some extent, systematically control resource pressure and constraints, and enable reproducible paired comparisons. Real capacities, traffic, bounds, and objectives may differ, but CORA's separate generation, checking, and evaluation support adaptation. We test stricter conditions; specific platforms still require real-data validation.

Table 5. Resource-pressure tests (positive favors CORA; paired 95% CIs).

ConditionFeasible/attemptedCORA ΔJComparator ΔJAdditional reduction [95% CI]
Control10/10-0.00989-0.00231+0.00758 [0.00332, 0.01290]
Tight delay8/10-0.01111-0.00341+0.00770 [0.00359, 0.01204]
Tight bandwidth10/10-0.00638-0.00169+0.00469 [0.00198, 0.00780]
Joint pressure7/10-0.02070-0.00350+0.01720 [0.00319, 0.03268]

Table 6. Bandwidth-perturbation tests (95% CIs).

StartFeasible/attemptedCORA ΔJAdditional reduction [95% CI]
MSH-OR12/12-0.03440+0.02986 [0.02189, 0.03779]
IHGE3/12-0.06071+0.04255 [0.01561, 0.08214]
MAT-GNN9/12-0.05832+0.04715 [0.02092, 0.07671]

These tests show CORA improves the same strictly feasible starts beyond a single loose-resource condition, including tight bandwidth/delay, joint pressure, and traffic perturbation.

[II] Questions

Q1. We add incremental exact greedy as a strict comparator sharing CORA's feasible starts, legal actions, and exact one-step objective information. It wins under tiny budgets;when budgets get bigger,for example at 25 evaluations, CORA still gains 0.002414 [0.000526, 0.005073] from the starts. CORA's gain thus comes from identifying actions with greater subsequent potential, not exclusive incremental information.

Thanks to the authors for the detailed response and the new experiments, which improve the paper. In particular, the ablation study helps clarify what RL adds.

My main remaining question is how CORA compares with greedy search when both use the same incremental objective information. The response reports a gain on MAT-GNN starts at 25 evaluations, but I couldn’t find that comparison in the revised PDF. Could you share the results for MSH-OR and IHGE starts and explain how incremental candidate scores counted toward the evaluation budget? I see merit in the proposed approach and will reconsider my score once this comparison is made clearer.

Table R. Additional objective reduction by CORA over exact incremental greedy; positive values favor CORA.

Start25 evaluations50 evaluations100 evaluations200 evaluations95% CI at 200 evaluations
MSH-OR+0.000708+0.001563+0.001563+0.001576[0.000419, 0.002816]
IHGE−0.000165+0.000966+0.001593+0.001716[0.000407, 0.003206]
MAT-GNN+0.002414+0.003115+0.003295+0.003298[0.000547, 0.007603]

We thank the reviewer for this important question. To address it, we extended the experiments to larger evaluation budgets, as shown above. At the relatively small budget of 25 evaluations, exact incremental greedy has a slight numerical advantage on IHGE starts. As the budget increases from 25 to 200 evaluations, CORA's mean advantage over exact incremental greedy grows for all three start providers, yielding clear gains. We will include the complete experimental curves(Appendix N.2,Figure 11) in the revised manuscript.

How incremental candidate scores count toward the evaluation budget.

We use the same cap on complete objective evaluations: the complete objective calculation for the initial deployment counts as one evaluation, and each subsequent complete objective recomputation for a selected successor counts as one additional evaluation. Incremental scores obtained through local updates during candidate scanning do not count as complete recomputations. Their calculation counts and constraint-check counts are recorded separately, while their actual costs are included in online time.

This protocol is reasonable and fair for its stated purpose: comparing the deployment quality that different search strategies achieve under the same complete-evaluation cap. CORA and exact incremental greedy use the same strictly feasible starts, candidate neighborhood, constraint rules, and objective function. The classical method can also directly use exact incremental information to select the action with the greatest immediate improvement. In other words, exact incremental greedy does not incur an additional complete recomputation for every candidate, nor is it restricted by lacking the information available to CORA.

Comments on the paper

1 comment
AuthorsOpenReview ↗

We clarify CORA’s contribution and report new matched comparisons, component ablations, and stress tests, while specifying its practical scope and revisions

To all reviewers and the AC: new evidence and revisions

Comment. We thank the reviewers for recognizing the problem's value, the useful construction–repair–improvement design, and the careful paired evaluation. Their questions motivated stronger controls and clearer claims.

The paper's claim. CORA is a provider-independent, strictly feasible post-optimizer for complete VNF deployments. It models each move or swap in both physical and service-chain graphs, screens actions exactly, and learns to allocate a limited multi-step search budget. Early ranking supervision and later policy-gradient optimization address the changing legal-action space; best-incumbent retention prevents deterioration from the repaired start.

ConcernNew evidenceResult
Is the gain only an evaluation-budget artifact?Same repaired starts and neighborhood; budgets of 3 and 25 complete evaluations. Separate online timing includes candidate work, graph inference, exact checks, and search control; training is separate.Against Best improvement, all six paired 95% intervals favor CORA: +0.00393–0.01364 at budget 3 and +0.00567–0.01965 at 25. Equal-time gains vary: MSH-OR versus First improvement is +0.00160 [0.00058, 0.00281], while IHGE favors classical search. We claim better use of limited evaluations, not universal speedup.CORA suits larger, coupled neighborhoods and nontrivial search windows; recurring requests may amortize training. Classical search may suit small, urgent, one-off tasks.
Do ranking supervision and RL each contribute?Matched component controls use the same starts, legal actions, action features, and search procedure.Full CORA improves over ranking-only GNN by +0.00129 [0.00062, 0.00209] and over RL-only GNN by +0.01589 [0.00766, 0.02526]. Ranking gives a stable action prior; RL adds measurable multi-step value.
Is graph context useful beyond local features?The action-feature MLP is a strong matched baseline; physical and service-chain relations are examined separately.Physical edges represent host resources, paths, and link competition; service edges represent predecessor–successor dependencies and end-to-end effects. Their joint representation avoids discarding either side of a VNF move.so we position graph context as a structurally motivated complement, not a universal replacement.
Does CORA have exclusive incremental information?We checked the four incremental descriptors against full objective recomputation and added exact-increment greedy search with the same feasible actions and local information.Greedy can be stronger with very few steps. When budgets get bigger,for example,at 25 evaluations on MAT-GNN starts, CORA still gains +0.002414 [0.000526, 0.005073]. The relevant distinction is multi-step action ordering, not access to a cheaper one-step objective.
Are synthetic settings too lenient or small?Tight-latency, tight-bandwidth, joint-pressure, traffic-shift, rejection, and ten-seed topology tests covering 120 SFCs and 1,024 hosts.Versus the same feature-prior baseline, extra reductions are +0.00770 [0.00359, 0.01204] for tight latency, +0.00469 [0.00198, 0.00780] for tight bandwidth, and +0.01720 [0.00319, 0.03268] for joint pressure. Gains persist under active constraints. Complete production traces are scarce; controlled synthetic tests are reproducible, while platform validation remains necessary.
Does value depend on the start and training cost?Three start providers, a small-instance conditional-optimality audit, and separate offline/online timing.CORA improves feasible starts from heuristic, evolutionary, and learned constructors. It retains a near-optimal start when no better feasible action exists. Training averages 1,026.7 seconds per policy replica in the reported setup; repeated related requests can amortize this one-time cost.

Revisions.

  1. Clarify the VNF-specific dual-relation state–action model, exact masking, and ranking-plus-RL training.
  2. Separate evaluation-matched, online-time, and training claims; identify where each search method is preferable.
  3. Add matched components, exact-increment controls, pressure and rejection tests, and ten-seed topology tests. Different protocols remain separate in the appendix.
  4. Distinguish modeled deployment feasibility from migration execution; duration, disruption, and controller overhead require platform validation.
  5. Provide the generator, checker, evaluation scripts, seeds, and weights for reproduction.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.