rabbitmq

This study addresses the challenges microservices face in dynamic environments—such as load fluctuations, network variations, and failures—which hinder the coordination of scaling, routing, and repair strategies. The work presents the first taxonomy for adaptive microservice management tailored to dynamic settings, systematically reviewing 84 systems and 13 evaluation artifacts across four dimensions: control placement, dynamic modeling, adaptation strategies, and evaluation evidence. It identifies critical limitations in existing approaches, particularly incomplete modeling of dynamics and insufficient evaluation fidelity, underscoring the importance of high-fidelity evaluation for realizing performance gains. The paper further outlines promising future directions, including cross-layer coordination, telemetry-driven control abstractions, and safe learning-based control, offering a structured roadmap for subsequent research.

Current automated market maker (AMM) designs lack a unified taxonomy and standardized evaluation criteria, resulting in elevated financial risk, suboptimal capital efficiency, and poor cross-domain adaptability. To address this, we propose the first systematic AMM taxonomy framework, integrating mechanism design, game-theoretic analysis, and software engineering principles to establish a verifiable and extensible modeling and comparative paradigm. Leveraging this framework, we design three AMM prototypes—each formally aligned with core token issuance and exchange requirements—thereby bridging the disciplinary gap between economic modeling and systems implementation. Our contributions include: (i) a rigorous, modular classification schema enabling principled AMM analysis; (ii) executable, specification-driven prototypes supporting formal verification; and (iii) a structured design methodology for developers, facilitating robust, multi-scenario deployment and advancing the engineering of sustainable cryptographic economies. (149 words)

This work addresses the lack of systematic performance evaluation for message-oriented middleware in resource-constrained IoT edge computing environments, which complicates middleware selection. To bridge this gap, the authors propose mq-bench, a unified benchmarking framework that conducts large-scale concurrent evaluations of eight mainstream message brokers—including Mosquitto, EMQX, RabbitMQ, and NATS—across three representative edge hardware platforms. The assessment encompasses key performance dimensions such as latency, throughput, and resource consumption. For the first time under a consistent experimental setup, the study contrasts lightweight and enterprise-grade brokers, uncovering how architectural design choices influence scalability and resource efficiency. Based on these insights, the paper provides practical deployment guidelines tailored to diverse IoT application scenarios.

High energy consumption of message systems in cloud environments remains a critical challenge for sustainable infrastructure. Method: This paper presents the first systematic quantification of how RabbitMQ architectural configurations and workload characteristics jointly affect energy efficiency. Leveraging a real-world deployed cluster, we design a multi-configuration, multi-workload benchmarking framework covering microservices and IoT scenarios, integrating custom monitoring, standardized load generation, and multi-dimensional power measurement tooling. We propose a reproducible methodology for evaluating message broker energy efficiency. Contribution/Results: Our analysis uncovers sensitivity patterns between key configuration parameters (e.g., persistence policies, queue topology, QoS settings) and workload features (e.g., throughput, message size, concurrency) with respect to energy consumption. Experiments achieve up to 31% power reduction. We release the first open-source, fine-grained RabbitMQ energy dataset—enabling green architecture selection, sustainable cloud cost modeling, and low-carbon infrastructure design.

Message reordering in the Actor model leads to unpredictable concurrent behavior. This paper introduces a protocol-constrained actor capability mechanism that integrates static capability control into the Actor model: a flow-sensitive type system enforces ordering and payload-type constraints on actor references, enabling safe replication and delegation; an effect system is further employed to construct a behavioral predictability verification framework. The approach statically guarantees, at compile time, that messages arrive in protocol-specified order—ensuring actors correctly handle any arrival sequence and eliminating runtime nondeterminism arising from reordering. To our knowledge, this is the first work to deeply integrate static capabilities with protocol-aware references to achieve strong, formal guarantees on Actor message ordering. It establishes a concurrency model for distributed systems that simultaneously ensures safety and formal verifiability.

This work proposes a multiparty session typing framework that supports asynchronous mixed choices to address the participant state inconsistency arising from such choices in asynchronous multiparty conversations. The framework tolerates transient state inconsistencies during protocol execution but rigorously ensures eventual convergence to a consistent global state through an extended mechanism for global types and their projection onto local types. Building on this theoretical foundation, we present the first end-to-end verification and Erlang/OTP code generation toolchain for asynchronous multiparty protocols featuring mixed choices. The practical viability and effectiveness of our approach are demonstrated through its successful application in refactoring the amqp_client module of RabbitMQ, confirming its applicability to real-world distributed systems.

Actor models (e.g., Erlang/Elixir) avoid shared-memory concurrency issues but remain prone to protocol violations and deadlocks due to asynchronous, unidirectional message passing. To address this, we propose the first behavioral type system supporting *mailbox types*, and design Pat—a novel actor-based programming language grounded in this system. Our contributions are threefold: (1) the first integration of mailbox types into a practical programming language; (2) a cooperative context algorithm based on quasi-linear types and reverse bidirectional type inference, ensuring both decidability and completeness; and (3) a precise semantic model of asynchronous communication, combining shuffle-regular expression semantics with a process-calculus–to–language semantic translation technique. We implement a prototype type checker and evaluate it on industrial factory automation scenarios and the Savina benchmark suite, demonstrating high-fidelity modeling of real-world actor communication patterns and effective detection of protocol errors.

This work addresses the correctness challenges in implementing linearizable atomic registers in asynchronous message-passing systems, where precise real-time ordering of operations is unavailable. By combining equivalence and indistinguishability arguments with message-chain theory, the paper rigorously establishes that ensuring linearizability necessitates the formation of extensive message chains between operations of any type. This result formally characterizes, for the first time, the inherent communication overhead imposed by linearizability in asynchronous settings, thereby establishing a fundamental lower bound on the communication complexity required for its implementation. The findings provide a theoretical foundation for understanding the structural constraints and design costs associated with achieving linearizable semantics in distributed systems.

This work addresses critical gaps in the Model Context Protocol (MCP) for enterprise-scale AI agent deployment—specifically, the absence of identity propagation, adaptive tool quotas, and structured error handling. To overcome these limitations, the paper introduces three key innovations: a Context-Aware Broker Protocol for dynamic agent coordination, an adaptive timeout budget allocation algorithm informed by heterogeneous latency distributions, and a machine-readable, structured error recovery framework. Validated in real-world production environments, the study distills a five-dimensional design principle set, a catalog of canonical failure scenarios, and a production-readiness checklist. Collectively, these contributions substantially enhance the reliability, observability, and maintainability of AI agent tool invocations in complex operational settings.

Current agent communication protocols generally lack mechanisms for semantic alignment, clarification, and verification, shifting semantic responsibility onto prompts or application logic and thereby causing poor interoperability and high maintenance costs. This work proposes, for the first time, a human-inspired three-layer communication framework—comprising communication, syntactic, and semantic layers—and systematically analyzes 18 mainstream protocols to expose their structural deficiencies in semantic coordination. Through layered modeling, technical debt identification, and scenario mapping, the study not only derives a practical protocol selection guide but also advances agent communication beyond mere message passing toward a new paradigm of shared understanding, laying the foundation for building semantically robust, secure, and interoperable agent ecosystems.

To address insufficient multi-objective load balancing in stream processing systems under complex workloads, this paper proposes a multi-tier collaborative scheduling framework. The framework introduces dynamic inter-layer coordination mechanisms and lightweight interfaces among schedulers, enabling seamless integration of novel scheduling policies. It jointly optimizes computational resource utilization, end-to-end latency, and throughput by integrating multi-objective optimization, distributed resource management, and real-time feedback control. Its key innovation lies in shifting hierarchical scheduling from static decoupling to dynamic collaboration—preserving scalability while significantly enhancing adaptability. Evaluated in Meta’s production environment, the system reliably processes TB-scale data with sub-second latency; it improves critical resource utilization by 27% and reduces tail latency by 41%.

A key open question in microservice resilience modeling is whether asynchronous semantics—such as Kafka-based message passing—must be explicitly represented in dependency graphs. Method: We propose the first fully automated approach to construct service dependency graphs with asynchronous semantics (e.g., non-blocking Kafka edges) and endpoint success predicates directly from raw OpenTelemetry traces, integrated with closed-loop validation via Monte Carlo simulation and chaos engineering experiments. Contribution/Results: Applied to the OpenTelemetry Demo real-world system, our method achieves end-to-end automation—from trace ingestion to dependency graph construction, availability prediction, and experimental validation—for the first time. Quantitative evaluation shows that incorporating asynchronous semantics has negligible impact (≤10⁻⁵) on instantaneous HTTP endpoint availability predictions; thus, a simple connectivity-based model suffices. This work advances trace-driven resilience modeling from manual, ad-hoc construction toward automation, standardization, and empirical verifiability.