Service Function Chaining Architecture for Multi-hop Split Inference and Learning

Masahiro Sasabe; Takanori Hara

REVIEW 4 major objections 5 minor 34 references

Service Function Chaining Architecture for Multi-hop Split Inference and Learning

T0 review · 4 major / 5 minor · reviewed 2026-08-04 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read This paper claims that multi-hop split inference and split learning can be realized as a Service Function Chaining problem, with split sub-models treated as transparent TCP proxies over SRv6, and that the resulting architecture supports dyn

desk verdict Genuinely new SFC-based split inference/learning architecture with a working prototype, but the Mininet evaluation's zero propagation delay and weak baseline make the latency claims overreaching. read the letter →

arxiv 2509.10001 v1 pith:VBTSQDRM submitted 2025-09-12 cs.NI

Takanori Hara , Masahiro Sasabe This is my paper · ORCID

classification cs.NI

keywords ServiceFunctionChainingMulti-hopSplitInferenceLearningNeuralSRv6TPROXYeBPFDynamicpathreconfiguration

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper proposes to run multi-hop split inference (MSI) and multi-hop split learning (MSL) as a Service Function Chaining (SFC) problem: each split sub-model becomes a Neural Service Function (NSF), and the ordered composition of NSFs is a service chain. The authors implement NSFs as transparent TCP proxies over Segment Routing over IPv6 (SRv6) with an eBPF-based SFC proxy that performs SRv6 encapsulation and decapsulation. The architecture lets the network dynamically reroute the model pipeline around congestion without modifying client or server applications. The prototype evaluation shows that the overhead of SRv6 is negligible compared to forward propagation compute, so the design is practical for real-time inference with small mini-batches and supports dynamic path reconfiguration for both inference and training.

What carries the argument

The central object is the Neural Service Function (NSF): a stateful network function that runs a split sub-model. It combines three existing technologies: SRv6 for source routing of the service path, TPROXY for transparent TCP interception that keeps clients and servers unaware of intermediate hops, and an eBPF-based SFC proxy that performs SRv6 encapsulation and decapsulation. The critical mechanism is the BPF map: it stores the relationship between the 5-tuple flow of an incoming SRv6 packet and its outer IPv6 header/SRH, and then re-uses that stored header when the NSF creates a new TCP connection to forward activations. This 'transparent TCP proxy chaining over SRv6' is what makes the se

What would settle it

Open two concurrent TCP connections with identical source/destination addresses and ports (e.g., via socket reuse or a NAT) to the same target through the same NSF; if the eBPF map lookup attaches the wrong SRH to either connection, the 5-tuple key assumption fails.

Watch

Extended reading notes

Core claim

The central claim is that the conceptual alignment between SFC and multi-hop split inference is not just a metaphor: split sub-models can genuinely be treated as network service functions, and a service chain of them executes the global model. The paper shows this by building NSFs that intercept TCP traffic transparently (via TPROXY), buffer packets into a byte stream, run the assigned sub-model, and forward activations onward, all while maintaining the original SRv6 segment routing context. A key technical step is the BPF-map association between the 5-tuple flow of an incoming packet and the outer IPv6 header/SRH, so that when the NSF opens a new TCP connection to the next hop, the eBPF pro

Load-bearing premise

The design relies on the 5-tuple flow key being unique and stable for an SRv6 session; if two TCP connections share the same 5-tuple, the wrong segment routing header could be applied and break the service chain.

Editorial extensions

If this is right

If correct, split inference and learning can be deployed over standard SRv6-capable networks with no changes to existing client–server applications.
Operators gain dynamic path reconfiguration (e.g., bypassing a congested link) through segment-list updates in the control plane, leaving the ML code untouched.
For real-time inference with small mini-batches (e.g., batch size 1), the added communication overhead is negligible because the smashed data is small and SRv6 processing is hidden behind compute.
For training, the architecture is feasible but the dominant cost remains the waiting time for backward-propagation gradients; the paper identifies asynchronous training and data compression as future mitigations.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

The 5-tuple flow-key lookup assumes uniqueness and stability; a testable extension is to include extra discriminators (e.g., an explicit session identifier) to handle NATs or connection reuse where two streams could share a 5-tuple.
The service-chain abstraction suggests the same infrastructure could support model composition across administrative domains, where each domain exposes an NSF as a network service, turning split learning into a deployable inter-operator offering.
The waiting-time bottleneck in MSL could be attacked by overlapping forward and backward passes across the chain; the SFC machinery could schedule such pipelining at the network layer.
The evaluation is on a single emulated topology; a natural next experiment is to vary link delays and loss to confirm that the eBPF/TPROXY path remains stable under realistic WAN conditions.

Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

Colleague,

Bottom line: this is a genuine architecture paper with a working prototype, but the evaluation is not strong enough to support the headline claims. The idea of treating split sub-models as service functions in an SRv6 chain, and using the same mechanism for the reverse gradient traffic in split learning, is new as far as I can tell. SRv6Pipes did byte-stream functions over SRv6, but not model execution with bidirectional training traffic. The NSF design is sensible, and the BPF map trick for re-associating the new TCP connection from a proxy with the original SRH is a nice piece of engineering. The prototype trains a real model and converges to the same accuracy as the baseline, which does show feasibility.

The soft spots are all in the evaluation. The stress-test note is correct: Mininet has bandwidth limits but no link propagation delay, so the SFC path's extra six hops are free. Claiming that SRv6 overhead is insignificant and that the architecture is 'particularly suitable for real-time inference' at batch size 1 is only supported in a zero-propagation environment. On a real 6G edge network, each hop adds latency, and 38ms forward propagation is not huge compared to that. The 'no significant difference' claim is also stated without error bars or multiple runs. The dynamic reconfiguration experiment uses a baseline that is simply assumed to lack the capability, so it demonstrates the mechanism works, not that it beats anything comparable. The 5-tuple collision concern in the BPF map is real but minor: TCP ephemeral ports usually avoid collisions, but the paper should at least mention the assumption and what happens on collision. No code is released, so reproducibility is limited.

The architecture is a reasonable contribution to the networking layer of split ML, and it deserves a serious referee. The right outcome is probably major revision: add propagation delays to the emulation, do repeated runs with variance, and compare the dynamic reconfiguration against a baseline that has a comparable (even if simpler) adaptation mechanism. I'd send this to review, not desk-reject.

Best.

Referee Report

4 major / 5 minor

Summary. The paper proposes an SFC-based architecture for multi-hop split inference (MSI) and multi-hop split learning (MSL). Split sub-models are encapsulated as 'Neural Service Functions' (NSFs), which act as transparent TCP proxies using TPROXY, SRv6, and eBPF-based SFC proxies. The architecture allows dynamic service paths by manipulating SRv6 segment lists, and it is extended to handle bidirectional training traffic for MSL. The authors implement a prototype in Mininet with a reduced-dimension ResNet101 on CIFAR-100 and compare it against traditional TCP proxy chaining. They report equivalent training/inference accuracy, no significant latency difference in inference and training, suitability for real-time small-batch inference, and effective dynamic path reconfiguration around congested links.

Significance. If the claims are substantiated, the paper would make a useful systems contribution: it bridges SFC/SRv6 networking with split learning/inference and demonstrates a working prototype that preserves model accuracy while enabling path adaptation. Strengths include the concrete implementation using C++/LibTorch/libbpf, the direct measurement rather than simulation of latencies, the reproducibility details, and the clear comparison of training convergence. The claims are, however, currently supported only in a Mininet environment with no propagation delays and with limited statistical reporting, so the broader networking conclusions are not yet fully established.

major comments (4)

[§IV-A and §IV-C] The Mininet setup applies bandwidth constraints but no link propagation delay. The SFC path traverses 9 links (v1-v2-v3-v6-v3-v4-v7-v4-v5-v8) while the baseline TCP proxy path traverses 3 links (v1-v6-v7-v8). With zero delay on every link, the extra 6 hops contribute no latency, so the conclusion that 'the overhead of SRv6 encapsulation and decapsulation is insignificant' (Section IV-C) is only demonstrated for a delay-free environment. In a real network, propagation, serialization, and queueing on those extra hops can be substantial relative to the ~38.7 ms per-round latency at b=1. This directly weakens the central claim that SFC-based MSI is 'particularly suitable for real-time inference.' I recommend adding experiments with per-link delays (e.g., a few ms per hop) or explicitly scoping the claim to the emulated local-network setting.
[§IV-C and §IV-D] The claim that 'there is no significant difference in inference latencies' and similarly for training is not backed by any statistical evidence. Figures 9 and 10 appear to report single measurements, with no error bars, no multiple runs, and no statistical test. Given that the observed differences (38.7 ms vs 39.2 ms) are small, the paper must show that the conclusion is robust across repetitions. Please report means, variances, and an appropriate test or confidence interval, or soften the claim accordingly.
[§IV-E] The dynamic reconfiguration experiment compares the proposed architecture against a baseline that is 'assumed to lack the capability to dynamically adjust the service path' (Section IV-E). This is not a comparable baseline: it does not demonstrate that the proposed control mechanism is better than, say, standard IP rerouting or a baseline with the same monitoring capability. The threshold used for congestion detection (bandwidth below 1 Mbps for 10 s during inference, 10 Mbps for training) is also an arbitrary free parameter, and no sensitivity analysis is provided. The experiment supports feasibility of the rerouting mechanism, but not the stronger conclusion that it 'minimizes the impact of control mechanisms' relative to viable alternatives.
[§III-C4 and Fig. 5] The BPF map is keyed by the 5-tuple of the inner TCP flow, and the NSF later maps the 5-tuple of its newly opened connection to the stored SRH. The paper does not discuss what happens when two connections share the same 5-tuple, e.g., after TCP source-port reuse, under NAT, or with spoofed packets. A stale or maliciously matching 5-tuple could cause the wrong SRH to be applied, breaking the service chain. This is a correctness gap in the chaining mechanism that should at least be discussed, and ideally hardened (e.g., by adding generation numbers or verifying the associated connection state).

minor comments (5)

[Captions of Figs. 9 and 10] Typo: 'reciving' should be 'receiving.'
[§III-C6] Typo: 'receving' should be 'receiving.'
[Reference [34]] The university name is misspelled: 'University of Tront' should be 'University of Toronto.'
[Reference [22]] The iptables project reference points to the libbpf GitHub URL, which appears to be a copy-paste error.
[§III-A2 and Fig. 2] The notation is inconsistent: the script uses '--dport' and '${DPORT}' where uppercase/lowercase distinction is not explained; this may confuse readers reproducing the configuration.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity: measured prototype, no fitted predictions; minor self-citations non-load-bearing.

full rationale

The paper is an empirical systems evaluation. The central claims—that the SFC architecture is feasible for MSI/MSL, that SRv6/TPROXY overhead is small, and that dynamic segment-list reconfiguration works—are supported by direct measurements of an implemented prototype against a traditional TCP-proxy baseline in Section IV. No equation is derived from its own output, and no quantity is fitted and then announced as a prediction. The 'service chain as global model' construction is a design mapping, not a derivation from a fitted parameter. The only self-citations are [18] (ordered proof of transit) and [27] (eBPF packet processing) in related-work/background; they support generic eBPF/SRv6 capabilities and are not used to justify the paper's novel architecture or its evaluation results, which are self-contained. The skeptical concern about Mininet having no propagation delay is an experimental-design limitation affecting external validity, not a circularity. Therefore no circular step is identified.

Assumptions & free parameters 1 free parameters · 4 assumptions · 1 invented entities

The central contribution is architectural, so most load-bearing inputs are protocol and software assumptions rather than fitted constants. The only hand-chosen number is the congestion threshold; the key reliability assumption is the 5-tuple key uniqueness in the BPF map.

free parameters (1)

Congestion detection bandwidth threshold = 1 Mbps inference, 10 Mbps training, sustained 10 s
Chosen by hand for the emulation; the mechanism works regardless of exact value, but these thresholds determine when rerouting triggers in the experiment.

assumptions (4)

domain assumption SRv6, TPROXY, and eBPF behave as documented in their specifications
The architecture relies on these kernel and protocol features working correctly; Section III-A describes them as standard mechanisms.
domain assumption The substrate network supports SRv6 and Software Resolved Networks (SRNs)
Section III-B3 assumes the network is SRv6-capable and SRN-assisted, which may not hold in all deployments.
domain assumption Application-layer byte-stream reconstruction at NSFs is lossless and ordered
Section III-C5 assumes the NSF can buffer TCP segments into a complete byte stream before model execution; any packet loss or reordering beyond TCP guarantees would break the chain.
domain assumption The global model is exactly representable as a sequential composition of sub-models
Section III-B2 defines the model as a disjoint partition of layers with no skip connections crossing cut points.

invented entities (1)

Neural Service Function (NSF)
purpose: Executes split sub-models as transparent TCP proxies within an SFC chain
New software component introduced in this paper; its functionality is only evidenced by the paper's prototype, not by an independent implementation.

how reviews work

0 comments

Cite this review

Pith. "Pith review of Service Function Chaining Architecture for Multi-hop Split Inference and Learning." pith.science (2026). https://pith.science/paper/VBTSQDRM

@misc{pith2026250910001,
  author       = {Pith},
  title        = {Pith review of: Service Function Chaining Architecture for Multi-hop Split Inference and Learning},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/VBTSQDRM}},
  note         = {Machine review of arXiv:2509.10001}
}

read the original abstract

Service Function Chaining (SFC) is a networking technique that ensures traffic traverses a predefined sequence of service functions, realizing arbitrary network services through dynamic and efficient communication paths. Inspired by this concept, we propose an SFC-based architecture for Multi-hop Split Inference (MSI), where split sub-models are interpreted as service functions and their composition forms a service chain representing the global model. By leveraging SFC, the proposed architecture dynamically establishes communication paths for split sub-models, ensuring efficient and adaptive execution. Furthermore, we extend this architecture to Multi-hop Split Learning (MSL) by applying SFC to the bidirectional communication required for training tasks. To realize the proposed architecture, we design Neural Service Functions (NSFs) to execute split sub-models as transparent TCP proxies and integrate them with Segment Routing over IPv6 (SRv6) and the extended Berkeley Packet Filter (eBPF)-based SFC proxy. This integration ensures efficient ML processing over dynamic routing while maintaining compatibility with existing applications. Evaluation results demonstrate that (1) the proposed architecture is feasible for both MSI and MSL; (2) it is particularly suitable for real-time inference in MSI scenarios with small mini-batch sizes; (3) it supports dynamic path reconfiguration, enabling adaptive responses to changing network conditions while minimizing the impact of control mechanisms on inference and learning processes.

Figures

Figures reproduced from arXiv: 2509.10001 by the authors.

**Figure 2.** Example configuration for TPROXY. 2) Transparent Proxy (TPROXY): TPROXY is a Linux kernel module that intercepts TCP traffic without altering the original packets [7]. It is typically configured using iptables [22]. When a packet matches specific rules, it is marked and redirected to a predefined target port. This allows clients to communicate via proxies while perceiving a direct connection to the server [PITH_FU… view at source ↗

**Figure 3.** Architecture of a neural service function (NSF). [PITH_FULL_IMAGE:figures/full_fig_p006_3.png] view at source ↗

Figures from the paper (8 more)

**Figure 5.** Figure 5: Key-value store updates for transparent TCP proxy [PITH_FULL_IMAGE:figures/full_fig_p006_5.png]

**Figure 4.** Figure 4: Structure of an SRv6 packet with the segments left [PITH_FULL_IMAGE:figures/full_fig_p006_4.png]

**Figure 6.** Figure 6: Experimental setup and network topology. [PITH_FULL_IMAGE:figures/full_fig_p007_6.png]

**Figure 8.** Figure 8: Training loss over time. similar trends: the forward propagation time remains nearly constant due to GPU acceleration and I/O overhead, while the activation transmission time increases as the batch size grows. The results indicate no significant difference in inference…

**Figure 9.** Figure 9: Comparison of the impact of batch size on per-round inference latencies between the proposed SFC-based MSI and [PITH_FULL_IMAGE:figures/full_fig_p009_9.png]

**Figure 10.** Figure 10: Comparison of per-round training latencies between the proposed SFC-based MSL and the baseline existing MSL. [PITH_FULL_IMAGE:figures/full_fig_p009_10.png]

**Figure 11.** Figure 11: Variation in per-round inference latency over time [PITH_FULL_IMAGE:figures/full_fig_p010_11.png]

**Figure 12.** Figure 12: Variation in per-round training latency over time ( [PITH_FULL_IMAGE:figures/full_fig_p010_12.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

34 extracted references · 6 linked inside Pith

[1]

Service Function Chaining (SFC) Architecture,

J. M. Halpern and C. Pignataro, “Service Function Chaining (SFC) Architecture,” RFC 7665, Oct. 2015. [Online]. Available: https://www.rfc-editor.org/info/rfc7665

2015
[2]

The Impact of the EU General Data Protection Regulation on Scientific Research,

G. Chassang, “The Impact of the EU General Data Protection Regulation on Scientific Research,”ecancer, vol. 11, no. 709, pp. 1–12, Jan. 2017

2017
[3]

Splitfed Learning without Client-Side Synchronization: Ana- lyzing Client-Side Split Network Portion Size to Overall Performance,

P. Joshi, C. Thapa, S. Camtepe, M. Hasanuzzamana, T. Scully, and H. Afli, “Splitfed Learning without Client-Side Synchronization: Ana- lyzing Client-Side Split Network Portion Size to Overall Performance,” Sep. 2021, arXiv:2109.09246

arXiv 2021
[4]

Hi- erarchical Split Federated Learning: Convergence Analysis and System Optimization,

Z. Lin, W. Wei, Z. Chen, C.-T. Lam, X. Chen, Y . Gao, and J. Luo, “Hi- erarchical Split Federated Learning: Convergence Analysis and System Optimization,” Dec. 2024, arXiv:2412.07197

arXiv 2024
[5]

MP-SL: Multihop Parallel Split Learning,

J. Tirana, S. Lalis, and D. Chatzopoulos, “MP-SL: Multihop Parallel Split Learning,” Jan. 2024, arXiv:2402.00208

arXiv 2024
[6]

Segment Routing over IPv6 (SRv6) Network Programming,

C. Filsfils, P. Camarillo, J. Leddy, D. V oyer, S. Matsushima, and Z. Li, “Segment Routing over IPv6 (SRv6) Network Programming,” RFC 8986, Feb. 2021. [Online]. Available: https://www.rfc-editor.org/info/ rfc8986

2021
[7]

Transparent Proxy Support,

The kernel development community, “Transparent Proxy Support,” https://docs.kernel.org/networking/tproxy.html, 2023, Accessed 18 Jun. 2024

2023
[8]

A Caching SFC Proxy Based on eBPF,

M. Haeberle, B. Steinert, M. Weiss, and M. Menth, “A Caching SFC Proxy Based on eBPF,” inProc. of International Conference on Network Softwarization (NetSoft), Jun. 2022, pp. 171–179

2022

Show all 34 references

[9]

Split Learning for Health: Distributed Deep Learning without Sharing Raw Patient Data,

P. Vepakomma, O. Gupta, T. Swedish, and R. Raskar, “Split Learning for Health: Distributed Deep Learning without Sharing Raw Patient Data,” Dec. 2018, arXiv:1812.00564

2018 arXiv
[10]

SplitFed: When Federated Learning Meets Split Learning,

C. Thapa, P. C. Mahawaga Arachchige, S. Camtepe, and L. Sun, “SplitFed: When Federated Learning Meets Split Learning,”Proc. of the AAAI Conference on Artificial Intelligence, vol. 36, no. 8, pp. 8485– 8493, Jun. 2022. 11

2022
[11]

A Bargaining Game for Personal- ized, Energy Efficient Split Learning over Wireless Networks,

M. Kim, A. DeRieux, and W. Saad, “A Bargaining Game for Personal- ized, Energy Efficient Split Learning over Wireless Networks,” inProc. of IEEE Wireless Communications and Networking Conference (WCNC), Mar. 2023, pp. 1–6

2023
[12]

Efficient Parallel Split Learning Over Resource-Constrained Wireless Edge Networks,

Z. Lin, G. Zhu, Y . Deng, X. Chen, Y . Gao, K. Huang, and Y . Fang, “Efficient Parallel Split Learning Over Resource-Constrained Wireless Edge Networks,”IEEE Transactions on Mobile Computing, vol. 23, no. 10, pp. 9224–9239, Oct. 2024

2024
[13]

Model Compression and Hardware Acceleration for Neural Networks: A Comprehensive Survey,

L. Deng, G. Li, S. Han, L. Shi, and Y . Xie, “Model Compression and Hardware Acceleration for Neural Networks: A Comprehensive Survey,” Proceedings of the IEEE, vol. 108, no. 4, pp. 485–532, Apr. 2020

2020
[14]

Communication and Computation Reduction for Split Learning using Asynchronous Training,

X. Chen, J. Li, and C. Chakrabarti, “Communication and Computation Reduction for Split Learning using Asynchronous Training,” inProc. of IEEE Workshop on Signal Processing Systems (SiPS), Oct. 2021, pp. 76–81

2021
[15]

HiveMind: Towards Cellular Native Machine Learning Model Splitting,

S. Wang, X. Zhang, H. Uchiyama, and H. Matsuda, “HiveMind: Towards Cellular Native Machine Learning Model Splitting,”IEEE Journal on Selected Areas in Communications, vol. 40, no. 2, pp. 626–640, Feb. 2022

2022
[16]

Accelerating Virtual Network Functions With Fast-Slow Path Architecture Using eXpress Data Path,

N. Van Tu, J.-H. Yoo, and J. Won-Ki Hong, “Accelerating Virtual Network Functions With Fast-Slow Path Architecture Using eXpress Data Path,”IEEE Transactions on Network and Service Management, vol. 17, no. 3, pp. 1474–1486, Sep. 2020

2020
[17]

On Achieving Trustworthy Service Function Chaining,

M. Pattaranantakul, Q. Song, Y . Tian, L. Wang, Z. Zhang, A. Meddahi, and C. V orakulpipat, “On Achieving Trustworthy Service Function Chaining,”IEEE Transactions on Network and Service Management, vol. 18, no. 3, pp. 3140–3153, Sep. 2021

2021
[18]

eBPF-Based Ordered Proof of Transit for Trustworthy Service Function Chaining,

T. Hara and M. Sasabe, “eBPF-Based Ordered Proof of Transit for Trustworthy Service Function Chaining,”IEEE Transactions on Network and Service Management, vol. 22, no. 4, pp. 3138–3149, Aug. 2025

2025
[19]

SARENA: SFC-Enabled Architecture for Adaptive Video Streaming Applications,

R. Farahani, A. Bentaleb, C. Timmerer, M. Shojafar, R. Prodan, and H. Hellwagner, “SARENA: SFC-Enabled Architecture for Adaptive Video Streaming Applications,” inProc. of IEEE International Con- ference on Communications, May 2023, pp. 864–870

2023
[20]

SRv6Pipes: Enabling In- Network Bytestream Functions,

F. Duchene, D. Lebrun, and O. Bonaventure, “SRv6Pipes: Enabling In- Network Bytestream Functions,” inProc. of IFIP Networking Confer- ence (IFIP Networking) and Workshops, May 2018, pp. 1–9

2018
[21]

Segment Routing: A Com- prehensive Survey of Research Activities, Standardization Efforts, and Implementation Results,

P. L. Ventre, S. Salsano, M. Polverini, A. Cianfrani, A. Abdelsalam, C. Filsfils, P. Camarillo, and F. Clad, “Segment Routing: A Com- prehensive Survey of Research Activities, Standardization Efforts, and Implementation Results,”IEEE Communications Surveys & Tutorials, vol. 23...

2021
[22]

iptables Project Homepage,

The netfilter.org project, “iptables Project Homepage,” https://github.com/libbpf/libbpf, 2025, Accessed 18 Jun. 2025

2025
[23]

eBPF: A New Approach to Cloud-Native Observability, Networking and Security for Current (5G) and Future Mobile Networks (6G and Beyond),

D. Soldani, P. Nahi, H. Bour, S. Jafarizadeh, M. F. Soliman, L. Di Gio- vanna, F. Monaco, G. Ognibene, and F. Risso, “eBPF: A New Approach to Cloud-Native Observability, Networking and Security for Current (5G) and Future Mobile Networks (6G and Beyond),”IEEE Access, vol. 11, ...

2023
[24]

Extended Berkeley Packet Filter: An Application Perspective,

H. Sharaf, I. Ahmad, and T. Dimitriou, “Extended Berkeley Packet Filter: An Application Perspective,”IEEE Access, vol. 10, pp. 126 370– 126 393, 2022

2022
[25]

eBPF/XDP Based Network Traffic Visualization and DoS Mitigation for Intelligent Service Protec- tion,

Y . Choe, J.-S. Shin, S. Lee, and J. Kim, “eBPF/XDP Based Network Traffic Visualization and DoS Mitigation for Intelligent Service Protec- tion,” inProc. of Advances in Internet, Data and Web Technologies, 2020, pp. 458–468

2020
[26]

Leveraging eBPF for Programmable Network Functions with IPv6 Segment Routing,

M. Xhonneux, F. Duchene, and O. Bonaventure, “Leveraging eBPF for Programmable Network Functions with IPv6 Segment Routing,” inProc. of the International Conference on emerging Networking EXperiments and Technologies, Dec. 2018, pp. 67–72

2018
[27]

Practicality of In-Kernel/User-Space Packet Processing Empowered by Lightweight Neural Network and Decision Tree,

T. Hara and M. Sasabe, “Practicality of In-Kernel/User-Space Packet Processing Empowered by Lightweight Neural Network and Decision Tree,”Computer Networks, vol. 240, pp. 110 188:1–18, Feb. 2024

2024
[28]

Software Resolved Networks: Rethinking Enterprise Networks with IPv6 Segment Routing,

D. Lebrun, M. Jadin, F. Clad, C. Filsfils, and O. Bonaventure, “Software Resolved Networks: Rethinking Enterprise Networks with IPv6 Segment Routing,” inProc. of the Symposium on SDN Research, Mar. 2018, pp. 1–14

2018
[29]

PyTorch: An Imperative Style, High- Performance Deep Learning Library,

A. Paszke, S. Gross, F. Massa, A. Lerer, J. Bradbury, G. Chanan, T. Killeen, Z. Lin, N. Gimelshein, L. Antiga, A. Desmaison, A. Köpf, E. Yang, Z. DeVito, M. Raison, A. Tejani, S. Chilamkurthy, B. Steiner, L. Fang, J. Bai, and S. Chintala, “PyTorch: An Imperative Style, High- P...

2019 arXiv
[30]

libbpf, “libbpf,” https://github.com/libbpf/libbpf, 2023, Accessed 18 Jun. 2024

2023
[31]

Mininet,

Mininet, “Mininet,” https://mininet.org, 2023, Accessed 18 Jun. 2024

2023
[32]

Deep Residual Learning for Image Recognition,

K. He, X. Zhang, S. Ren, and J. Sun, “Deep Residual Learning for Image Recognition,” inProc. of IEEE Conference on Computer Vision and Pattern Recognition (CVPR), Jun. 2016, pp. 770–778

2016
[33]

Improved Regularization of Convolutional Neural Networks with Cutout,

T. DeVries and G. W. Taylor, “Improved Regularization of Convolutional Neural Networks with Cutout,” Nov. 2017, arXiv:1708.04552

2017 arXiv
[34]

Learning Multiple Layers of Features from Tiny Im- ages,

A. Krizhevsky, “Learning Multiple Layers of Features from Tiny Im- ages,” Master’s thesis, University of Tront, 2009

2009

Pith tools

Reviewed August 4, 2026 · model on record in the stance chip above.

[1] [1]

Service Function Chaining (SFC) Architecture,

J. M. Halpern and C. Pignataro, “Service Function Chaining (SFC) Architecture,” RFC 7665, Oct. 2015. [Online]. Available: https://www.rfc-editor.org/info/rfc7665

2015

[2] [2]

The Impact of the EU General Data Protection Regulation on Scientific Research,

G. Chassang, “The Impact of the EU General Data Protection Regulation on Scientific Research,”ecancer, vol. 11, no. 709, pp. 1–12, Jan. 2017

2017

[3] [3]

Splitfed Learning without Client-Side Synchronization: Ana- lyzing Client-Side Split Network Portion Size to Overall Performance,

P. Joshi, C. Thapa, S. Camtepe, M. Hasanuzzamana, T. Scully, and H. Afli, “Splitfed Learning without Client-Side Synchronization: Ana- lyzing Client-Side Split Network Portion Size to Overall Performance,” Sep. 2021, arXiv:2109.09246

arXiv 2021

[4] [4]

Hi- erarchical Split Federated Learning: Convergence Analysis and System Optimization,

Z. Lin, W. Wei, Z. Chen, C.-T. Lam, X. Chen, Y . Gao, and J. Luo, “Hi- erarchical Split Federated Learning: Convergence Analysis and System Optimization,” Dec. 2024, arXiv:2412.07197

arXiv 2024

[5] [5]

MP-SL: Multihop Parallel Split Learning,

J. Tirana, S. Lalis, and D. Chatzopoulos, “MP-SL: Multihop Parallel Split Learning,” Jan. 2024, arXiv:2402.00208

arXiv 2024

[6] [6]

Segment Routing over IPv6 (SRv6) Network Programming,

C. Filsfils, P. Camarillo, J. Leddy, D. V oyer, S. Matsushima, and Z. Li, “Segment Routing over IPv6 (SRv6) Network Programming,” RFC 8986, Feb. 2021. [Online]. Available: https://www.rfc-editor.org/info/ rfc8986

2021

[7] [7]

Transparent Proxy Support,

The kernel development community, “Transparent Proxy Support,” https://docs.kernel.org/networking/tproxy.html, 2023, Accessed 18 Jun. 2024

2023

[8] [8]

A Caching SFC Proxy Based on eBPF,

M. Haeberle, B. Steinert, M. Weiss, and M. Menth, “A Caching SFC Proxy Based on eBPF,” inProc. of International Conference on Network Softwarization (NetSoft), Jun. 2022, pp. 171–179

2022