Update pooria_additional.bib

Author: PooriaNamyar

_bibliography/people/pooria_additional.bib

@@ -1 +1,102 @@
+@inproceedings{namyar2025mitigation,
+  title={Enhancing Network Failure Mitigation with Performance-Aware Ranking},
+  author={Namyar, Pooria and Ghavidel, Arvin and Crankshaw, Daniel and Berger, Daniel S and Hsieh, Kevin and Kandula, Srikanth and Govindan, Ramesh and Arzani, Behnaz},
+  booktitle = {22nd USENIX Symposium on Networked Systems Design and Implementation (NSDI 25)},
+  year={2025},
+  abbr={NSDI},
+  url={https://arxiv.org/abs/2305.13792},
+  abstract={Cloud providers install mitigations to reduce the impact of network failures in their datacenters. To determine the best action, existing automatic network mitigation systems rely on simple local criteria or global proxy metrics. In this paper, we show that we can explicitly optimize end-to-end flow-level metrics and analyze actions holistically to support a broader range of actions and select much more effective mitigations. To this end, we develop novel techniques to quickly estimate the impact of different mitigations and rank them with high fidelity. Our results on incidents from a large cloud provider show orders of magnitude improvements in flow completion time and throughput. We also show our approach scales to large datacenters.}
+}
 
+@inproceedings{alcoz2025packs,
+  title={Everything Matters in Programmable Packet Scheduling},
+  author={Alcoz, Albert Gran and Vass, Balázs and Namyar, Pooria and Arzani, Behnaz and Rétvári, Gábor and Vanbever, Laurent},
+  booktitle = {22nd USENIX Symposium on Networked Systems Design and Implementation (NSDI 25)},
+  year={2025},
+  abbr={NSDI},
+  url={https://www.research-collection.ethz.ch/handle/20.500.11850/625335},
+  abstract={Operators can deploy any scheduler they desire on existing switches through programmable packet schedulers: they tag packets with ranks (which indicate their priority) and schedule them in the order of these ranks. The ideal programmable scheduler is the Push-In First-Out (PIFO) queue, which schedules packets in a perfectly sorted order by “pushing” packets into any position of the queue based on their ranks. However, it is hard to implement PIFO queues in hardware due to their need to sort packets at line rate (based on their ranks). Recent proposals approximate PIFO behaviors on existing data-planes. While promising, they fail to simultaneously capture both of the necessary behaviors of PIFO queues: their scheduling behavior and admission control. We introduce PACKS, an approximate PIFO scheduler that addresses this problem. PACKS runs on top of a set of priority queues and uses packet-rank information and queue-occupancy levels during enqueue to determine whether to admit each incoming packet and to which queue it should be mapped. We fully implement PACKS in P4 and evaluate it on real workloads. We show that PACKS better approximates PIFO than state-of-the-art approaches. Specifically, PACKS reduces the rank inversions by up to 7× and 15× with respect to SP-PIFO and AIFO, and the number of packet drops by up to 60% compared to SP-PIFO. Under pFabric ranks, PACKS reduces the mean FCT across small flows by up to 33% and 2.6×, compared to SP-PIFO and AIFO. We also show that PACKS runs at line rate on existing hardware (Intel Tofino).}
+}
+
+@inproceedings{namyar2024learning,
+  author = {Namyar, Pooria and Schapira, Michael and Govindan, Ramesh and Segarra, Santiago and Beckett, Ryan and Kakarla, Siva Kesava Reddy and Arzani, Behnaz},
+  title = {End-to-End Performance Analysis of Learning-enabled Systems},
+  year = {2024},
+  isbn = {9798400712722},
+  publisher = {Association for Computing Machinery},
+  address = {New York, NY, USA},
+  url = {https://doi.org/10.1145/3696348.3696875},
+  doi = {10.1145/3696348.3696875},
+  abstract = {We propose a performance analysis tool for learning-enabled systems that allows operators to uncover potential performance issues before deploying DNNs in their systems. The tools that exist for this purpose require operators to faithfully model all components (a white-box approach) or do inefficient black-box local search. We propose a gray-box alternative, which eliminates the need to precisely model all the system's components. Our approach is faster and finds substantially worse scenarios compared to prior work. We show that a state-of-the-art learning-enabled traffic engineering pipeline can underperform the optimal by 6\texttimes{} --- a much higher number compared to what the authors found.},
+  booktitle = {Proceedings of the 23rd ACM Workshop on Hot Topics in Networks},
+  pages = {86–94},
+  numpages = {9},
+  keywords = {Machine Learning for Systems, Performance Analysis},
+  location = {Irvine, CA, USA},
+  series = {HOTNETS '24},
+  abbr={HotNets},
+}
+
+@inproceedings{karimi2024Xplain,
+  author = {Karimi, Pantea and Pirelli, Solal and Kakarla, Siva Kesava Reddy and Beckett, Ryan and Segarra, Santiago and Li, Beibin and Namyar, Pooria and Arzani, Behnaz},
+  title = {Towards Safer Heuristics With XPlain},
+  year = {2024},
+  isbn = {9798400712722},
+  publisher = {Association for Computing Machinery},
+  address = {New York, NY, USA},
+  url = {https://doi.org/10.1145/3696348.3696884},
+  doi = {10.1145/3696348.3696884},
+  abstract = {Many problems that cloud operators solve are computationally expensive, and operators often use heuristic algorithms (that are faster and scale better than optimal) to solve them more efficiently. Heuristic analyzers enable operators to find when and by how much their heuristics underperform. However, these tools do not provide enough detail for operators to mitigate the heuristic's impact in practice: they only discover a single input instance that causes the heuristic to underperform (and not the full set) and they do not explain why.We propose XPlain, a tool that extends these analyzers and helps operators understand when and why their heuristics underperform. We present promising initial results that show such an extension is viable.},
+  booktitle = {Proceedings of the 23rd ACM Workshop on Hot Topics in Networks},
+  pages = {68–76},
+  numpages = {9},
+  keywords = {Domain-Specific Language, Explainable Analysis, Heuristic Analysis},
+  location = {Irvine, CA, USA},
+  series = {HOTNETS '24},
+  abbr={HotNets},
+}
+
+@article{Chitavis2023,
+  author={Chitavisutthivong, Kanatip and Supittayapornpong, Sucha and Namyar, Pooria and Zhang, Mingyang and Yu, Minlan and Govindan, Ramesh},
+  journal={IEEE/ACM Transactions on Networking},
+  abbr = {ToN},
+  title={Optimal Oblivious Routing With Concave Objectives for Structured Networks}, 
+  year={2023},
+  pages={1-13},
+  doi={10.1109/TNET.2023.3264632},
+  url={https://ieeexplore.ieee.org/document/10100699},
+  abstract = {Oblivious routing distributes traffic from sources to destinations following predefined routes with rules independent of traffic demands. While finding optimal oblivious routing with a concave objective is intractable for general topologies, we show that it is tractable for structured topologies often used in datacenter networks. To achieve this, we apply graph automorphism and prove the existence of the optimal automorphism-invariant solution. This result reduces the search space to targeting the optimal automorphism-invariant solution. We design an iterative algorithm to obtain such a solution by alternating between convex optimization and a linear program. The convex optimization finds an automorphism-invariant solution based on representative variables and constraints, making the problem tractable. The linear program generates adversarial demands to ensure the final result satisfies all possible demands. Since the construction of the representative variables and constraints are combinatorial problems, we design polynomial-time algorithms for the construction. We evaluate the iterative algorithm in terms of throughput performance, scalability, and generality over three potential applications. The algorithm i) improves the throughput up to $87.5\%$ for partially deployed FatTree and achieves up to $2.55\times$ throughput gain for DRing over heuristic algorithms, ii) scales for three considered topologies with a thousand switches, iii) applies to a general structured topology with non-uniform link capacity and server distribution.},
+}
+
+@inproceedings{HeuristicVerifier,
+  author = {Pooria Namyar and Behnaz Arzani and Ryan Beckett and Santiago Segarra and Himanshu Raj and Srikanth Kandula},
+  title = {Minding the Gap between Fast Heuristics and Their Optimal Counterparts},
+  abbr={HotNets},
+  year = {2022},
+  isbn = {9781450398992},
+  publisher = {Association for Computing Machinery},
+  address = {New York, NY, USA},
+  url = {https://doi.org/10.1145/3563766.3564102},
+  doi = {10.1145/3563766.3564102},
+  abstract = {Production systems use heuristics because they are faster or scale better than the corresponding optimal algorithms. Yet, practitioners are often unaware of how worse off a heuristic's solution may be with respect to the optimum in realistic scenarios. Leveraging two-stage games and convex optimization, we present a provable framework that unveils settings where a given heuristic underperforms.},
+  booktitle = {Proceedings of the 21st ACM Workshop on Hot Topics in Networks},
+  pages = {138–144},
+  numpages = {7},
+  keywords = {network management, adversarial inputs, heuristics},
+  location = {Austin, Texas},
+  series = {HotNets '22}
+}
+
+@INPROCEEDINGS{Sucha2022,
+  author={Sucha Supittayapornpong, and Pooria Namyar, and Mingyang Zhang, and Minlan Yu, and Ramesh Govindan},
+  booktitle={IEEE INFOCOM 2022 - IEEE Conference on Computer Communications}, 
+  title={Optimal Oblivious Routing for Structured Networks},
+  url = {https://ieeexplore.ieee.org/abstract/document/9796682},
+  abstract = {Oblivious routing distributes traffic from sources to destinations following predefined routes with rules independent of traffic demands. While finding optimal oblivious routing is intractable for general topologies, we show that it is tractable for structured topologies often used in datacenter networks. To achieve this, we apply graph automorphism and prove the existence of the optimal automorphism-invariant solution. This result reduces the search space to targeting the optimal automorphism-invariant solution. We design an iterative algorithm to obtain such a solution by alternating between two linear programs. The first program finds an automorphism-invariant solution based on representative variables and constraints, making the problem tractable. The second program generates adversarial demands to ensure the final result satisfies all possible demands. Since, the construction of the representative variables and constraints are combinatorial problems, we design polynomial-time algorithms for the construction. We evaluate proposed iterative algorithm in terms of throughput performance, scalability, and generality over three potential applications. The algorithm i) improves the throughput up to 87.5% over a heuristic algorithm for partially deployed FatTree, ii) scales for FatClique with a thousand switches, iii) is applicable to a general structured topology with non-uniform link capacity and server distribution.},
+  year={2022},
+  volume={},
+  number={},
+  abbr = {INFOCOM},
+  pages={1988-1997},
+  doi={10.1109/INFOCOM48880.2022.9796682}
+}