State-based Function Call (SFC)

• SFC is a framework where function execution is governed by explicit state management, enabling secure computations and optimized resource allocation in virtualized environments.
• It employs specialized protocols like SWOT and BOOT within OT schemes to balance privacy and efficiency, achieving measurable rates and secure two-party computation.
• SFC underpins applications in NFV, MEC, and congestion control, integrating transactional state management to ensure scalability, robustness, and low-latency operation.

State-based Function Call (SFC) constitutes a class of models and protocols where the execution of functions—typically over distributed or virtualized architectures—is fundamentally governed by the explicit management and evolution of state. In academic literature, SFC spans secure computation, network congestion control, virtualized networking, and transactional management in service function chains. The paradigm leverages state as a principal resource for synchronizing, scheduling, optimizing, and securing the interactions within chains of functions, whether these execute in cryptographic, edge computing, data center, or NFV contexts.

1. Information Theoretic Framework for Secure Two-Party Function Computation

SFC arises in secure two-party computation when each party holds private datasets sampled from a joint distribution and seeks to interactively compute output functions while preserving privacy. The fundamental abstraction involves exchanging messages over a reliable discussion channel and utilizing correlated randomness—a resource either sourced from a joint probability distribution (source model) or produced via a discrete memoryless channel (channel model), such as the binary erasure channel (BEC) or binary erasure source (BES).

Formally, the parties compute outputs $F^k = \{f(A_1, B_1),...,f(A_k,B_k)\}$ and $G^k = \{g(A_1, B_1),...,g(A_k,B_k)\}$, with rigorous privacy defined by conditional mutual information constraints on locally generated randomness, channel observations, and exchanged messages. The SFC rate, $R$, is the ratio of computed function samples to consumed randomness samples, and the SFC capacity, $C$, is the supremum achievable rate for given resources (0902.0822).

2. Oblivious Transfer Protocols within the SFC Framework

Oblivious transfer (OT) is a pivotal primitive in secure SFC, supporting efficient, information-theoretic privacy against semi-honest adversaries:

Sample-wise Oblivious Transfer (SWOT)

• Alice’s dataset forms a $k \times m$ matrix, with Bob selecting one bit per row and learning only those bits.
• The protocol partitions channel outputs into erased and non-erased sets, using XOR masking (one-time pads) to secure information flows.
• Achievable rate: $R_{OT,m} = \min(1-p,\, p/(m-1))$, where $p$ is the erasure probability of the BEC/BES. This rate is capacity-achieving for uniform sources.

Bootstrap String OT (BOOT)

• Designed for the string OT problem, BOOT relaxes privacy from joint to disjoint (allowing leakage of combined functions but not individual strings).
• BOOT bootstraps multiple SWOT rounds, parameterized by $(s_1,\ldots,s_u)$ with $\prod_{i=1}^u s_i \geq m$.
• Achievable rate: $$\widetilde{R}_{OT,m} = \left(\sum_{i=1}^u \frac{1}{R_{OT,s_i}}\right)^{-1}$$, enabling rates up to a multiplicative factor of $(m-1)/\lceil \log_2 m \rceil$ over SWOT by tolerating reduced privacy (0902.0822).

3. Security/Rate Trade-offs and Capacity Bounds

There exists a fundamental trade-off between privacy guarantees and achievable rate in state-based SFC protocols leveraging BES/BEC:

• For strong (joint) privacy, SWOT must allocate sufficient erasures for masking, with maximal capacity at $p^* = (m-1)/m$.
• BOOT, by exploiting disjoint privacy, more efficiently recycles erasures, favoring higher rates provided that leakage of joint properties is tolerable.
• The general SFC protocol (GSFC) employs these OT primitives to construct broader secure computation protocols. Its rate is:

$$R = \left( \frac{h_B}{R_{OT,m_A}} + \frac{h_A}{R_{OT,m_B}} \right)^{-1}$$

where $h_B = \lceil \log_2 |\mathbb{R}_g| \rceil$, $m_A = |\mathbb{A}|$, and analogous definitions apply for Alice.

This construction provides a distribution-free, information-theoretically secure lower bound on SFC capacity, $C \geq R$, directly implied by the underlying OT primitive’s performance (0902.0822).

4. SFC in Networked and Virtualized Systems

The SFC concept also structures virtual network service deployment and resource allocation in multi-access edge computing (MEC) and NFV:

• In NFV-enabled MEC, SFCs are ordered chains of virtual network functions (VNFs), each parameterizable and dynamically mapped onto infrastructure nodes.
• In partial offloading contexts, tasks are partitioned between local and remote SFC instantiations, demanding joint optimization of partition ratios and VNF placements (Wang et al., 2022).

Table: SFC Optimization in MEC/NFV Environments

Application	SFC Role	Optimization Objective
Mobile IoT task offloading	VNF ordering, mapping, parallelism	Minimize delay, energy, and usage cost
Edge resource allocation	Placement of chained VNFs	Balance load, satisfy constraints, optimize cost

5. SFC for Congestion Control: Source Flow Control Mechanisms

SFC appears in data center congestion management via source-based control schemes (Le et al., 2023). The SFC approach includes:

• Back-to-Sender (BTS) Signaling: Switches detect incipient queue buildup and send explicit pause instructions to the traffic source.
• In-network Caching: Near-edge switches retain and apply learned pause intervals to subsequent packets, drastically shortening feedback loops from multi-hop RTTs to local sub-RTT signaling.
• Performance benefits include 1.2–6× reduction in 99th-percentile flow completion time and 2–3× reduction in peak buffer occupancy.

Theoretical buffer reduction is described as:

$\Delta B = R \times (2T_B + k \cdot T_S)$

where $R$ is port speed, $T_B$ switch-to-receiver delay, $T_S$ serialization delay, and $k$ packet counting coefficient.

6. Transactional State Management in Stateful SFCs

Transactional semantics are applied to state-based function calls to ensure robust operation of SFCs in NFV (Yang et al., 2023):

• DB4NFV encapsulates all state accesses as database transactions, guaranteeing atomicity, consistency, isolation, and durability (ACID).
• The API enables specification of state objects/properties, declarative transaction logic for VNFs, and chain topologies as directed acyclic graphs.
• The runtime exploits multicore architectures using adaptive scheduling based on task precedence graphs—leveraging caching, modularization, and intelligent dependency tracking for enhanced throughput and reliability.
• Fault tolerance is achieved via multi-version state storage and snapshot/rollback mechanisms; per-flow and cross-flow state migration accommodates network dynamics and scaling events.

Comparison against existing frameworks demonstrates advantages in usability, concurrency control, and robustness, with trade-offs mainly localized to integration and abstraction overhead.

7. Implications and Contextual Significance

State-based function call frameworks provide the foundation for realizing secure, performant, and resilient distributed function execution. In secure computation, SFC protocols derive their achievable rates and privacy guarantees from the properties of underlying noisy resources and cryptographic primitives—especially OT. In modern networked systems, SFC structuring enables granular resource management, low-latency data flows, and robust stateful service orchestration. The integration of transactional semantics reflects a convergence of database principles with NFV and chain execution, facilitating correctness, concurrency, fault tolerance, and practical scalability.

The pivotal role of correlated state—whether in the form of randomness, system configuration, or transaction management—highlights state-based function call as a unifying abstraction spanning cryptographic, virtualized, and network control domains. Any advances in underlying state-masking, efficiency, or resource adaptation have direct effects on the function computation capacity, end-to-end latency, and deployment viability of SFC-driven architectures.