搜索结果：server

The Language Server Protocol (LSP) has revolutionized the integration of code intelligence in modern software development. There are approximately 300 LSP server implementations for various languages and 50 editors offering LSP integration. However, the reliability of LSP servers is a growing concern, as crashes can disable all code intelligence features and significantly impact productivity, while vulnerabilities can put developers at risk even when editing untrusted source code. Despite the widespread adoption of LSP, no existing techniques specifically target LSP server testing. To bridge this gap, we present LSPFuzz, a grey-box hybrid fuzzer for systematic LSP server testing. Our key insight is that effective LSP server testing requires holistic mutation of source code and editor operations, as bugs often manifest from their combinations. To satisfy the sophisticated constraints of LSP and effectively explore the input space, we employ a two-stage mutation pipeline: syntax-aware mutations to source code, followed by context-aware dispatching of editor operations. We evaluated LSPFuzz on four widely used LSP servers. LSPFuzz demonstrated superior performance compared to baseline

Drone delivery systems violate a core assumption in classical queueing models: server capacity is not fixed. Drones (servers) periodically must recharge, creating random fluctuations in service availability. We introduce an Erlang--S$^{*}$ queue that incorporates charging dynamics (probability of charging after service completion $p$ and charging return rate $γ$) together with abandonment. We derive fluid and diffusion limits, yielding closed-form steady-state means, variances, and covariances for the joint queue--server process $(Q,S)$. The diffusion limits allow us to derive new staffing rules for the probability of delay and the probability of abandonment targets. A key insight is that server stochasticity induces systematic capacity loss relative to fixed--server systems, leading to a regime--dependent staffing adjustment: additive shifts in underloaded regimes and multiplicative scaling in overloaded regimes. Our simulation experiments confirm both the accuracy of the limit theorems and the performance of the staffing schedule's ability to achieve their targets.

Federated learning (FL) with a single global server framework is currently a popular approach for training machine learning models on decentralized environment, such as mobile devices and edge devices. However, the centralized server architecture poses a risk as any challenge on the central/global server would result in the failure of the entire system. To minimize this risk, we propose a novel federated learning framework that leverages the deployment of multiple global servers. We posit that implementing multiple global servers in federated learning can enhance efficiency by capitalizing on local collaborations and aggregating knowledge, and the error tolerance in regard to communication failure in the single server framework would be handled. We therefore propose a novel framework that leverages the deployment of multiple global servers. We conducted a series of experiments using a dataset containing the event history of electric vehicle (EV) charging at numerous stations. We deployed a federated learning setup with multiple global servers and client servers, where each client-server strategically represented a different region and a global server was responsible for aggregating

Two popular server control policies are available for reducing energy consumption while maintaining acceptable performance levels: server speed scaling and the ability to turn servers off (and on). In this work, we explore the question of whether there are synergistic effects between these two mechanisms. To do this, we employ a continuous-time Markov chain model where the server can be turned off (and turning the server back on takes some time) and where the speed of the server can take on two values: a nominal operating speed and a reduced operating speed. For a cost function that is linear in the mean response time and server power consumption, we suggest that the mechanisms are not synergistic in that for all system loads, one mechanism is dominant in that if the other mechanism is also employed, there is only a small decrease in cost.

Secure aggregation usually aims at securely computing the sum of the inputs from $K$ users at a server. Noticing that the sum might inevitably reveal information about the inputs (when the inputs are non-uniform) and typically the users (not the server) desire the sum (in applications such as federated learning), we consider a variant of secure aggregation where the server is oblivious, i.e., the server only serves as a communication facilitator/helper to enable the users to securely compute the sum and learns nothing in the process. Our communication protocol involves one round of messages from the users to the server and one round of messages from the server to each user such that in the end each user only learns the sum of all $K$ inputs and the server learns no information about the inputs. For this secure aggregation with an oblivious server problem, we show that to compute $1$ bit of the sum securely, each user needs to send at least $1$ bit to the server, the server needs to send at least $1$ bit to each user, each user needs to hold a key of at least $2$ bits, and all users need to collectively hold at least $K$ key bits. In addition, when user dropouts are allowed, the opt

In most service systems, the servers are humans who desire to experience a certain level of idleness. In call centers, this manifests itself as the call avoidance behavior, where servers strategically adjust their service rate to strike a balance between the idleness they receive and effort to work harder. Moreover, being humans, each server values this trade-off differently and has different capabilities. Drawing ideas on mean-field games we develop a novel framework relying on measure-valued processes to simultaneously address strategic server behavior and inherent server heterogeneity in service systems. This framework enables us to extend the recent literature on strategic servers in four new directions by: (i) incorporating individual choices of servers, (ii) incorporating individual abilities of servers, (iii) modeling the discomfort experienced by servers due to low levels of idleness, and (iv) considering more general routing policies. Using our framework, we are able to asymptotically characterize asymmetric Nash equilibria for many-server systems with strategic servers. In simpler cases, it has been shown that the purely quality-driven regime is asymptotically optimal. Ho

In this paper, we consider a goal-oriented communication problem for edge server monitoring, where jobs arrive intermittently at multiple dispatchers and must be assigned to shared edge servers with finite queues and time-varying availability. Accurate knowledge of server status is critical for sustaining high throughput, yet remains challenging under dynamic workloads and partial observability. To address this challenge, each dispatcher maintains server knowledge through two complementary mechanisms: (i) active status queries that provide instantaneous updates at a communication cost, and (ii) job execution feedback that reveals server conditions upon successful or failed job completion. We formulate a cooperative multi-agent distributed decision-making problem in which dispatchers jointly optimize query scheduling to balance throughput against communication overhead. To solve this problem, we propose a Multi-Agent Proximal Policy Optimization (MAPPO)-based algorithm that leverages centralized training with decentralized execution (CTDE) to learn distributed query-and-dispatch policies under partial and stale observations. Experiments show that MAPPO achieves superior throughput-c

Performance in web applications is a key aspect of user experience and system scalability. Among the different techniques used to improve web application performance, caching has been widely used. While caching has been widely explored in web performance optimization literature, there is a lack of experimental work that explores the effect of simple inmemory caching in small-scale web applications. This paper fills this research gap by experimentally comparing the performance of two server-side web application configurations: one without caching and another with in-memory caching and a fixed time-tolive. The performance evaluation was conducted using a lightweight web server framework, and response times were measured using repeated HTTP requests under identical environmental conditions. The results show a significant reduction in response time for cached requests, and the findings of this paper provide valuable insights into the effectiveness of simple server-side caching in improving web application performance making it suitable for educational environments and small-scale web applications where simplicity and reproducibility are critical.

A service system with multiple types of customers, arriving as Poisson processes, is considered. The system has infinite number of servers, ranked by $1,2,3, \ldots$; a server rank is its ``location." Each customer has an independent exponentially distributed service time, with the mean determined by its type. Multiple customers (possibly of different types) can be placed for service into one server, subject to ``packing'' constraints. Service times of different customers are independent, even if served simultaneously by the same server. The large-scale asymptotic regime is considered, such that the mean number of customers $r$ goes to infinity. We seek algorithms with the underlying objective of minimizing the location (rank) $U$ of the right-most (highest ranked) occupied (non-empty) server. Therefore, this objective seeks to minimize the total number $Q$ of occupied servers {\em and} keep the set of occupied servers as far at the ``left'' as possible, i.e., keep $U$ close to $Q$. In previous work, versions of {\em Greedy Random} (GRAND) algorithm have been shown to asymptotically minimize $Q/r$ as $r\to\infty$. In this paper we show that when these algorithms are combined with t

An optimal control problem with heterogeneous servers to minimize the average age of information (AoI) is considered. Each server maintains a separate queue, and each packet arriving to the system is randomly routed to one of the servers. Assuming Poisson arrivals and exponentially distributed service times, we first derive an exact expression of the average AoI for two heterogeneous servers. Next, to solve for the optimal average AoI, a close approximation is derived, called the approximate AoI, this is shown to be useful for multi-server systems as well. We show that for the optimal approximate AoI, server utilization (ratio of arrival rate and service rate) for each server should be same as the optimal server utilization with a single server queue. For two identical servers, it is shown that the average AoI is approximately 5/8 times the average AoI of a single server. Furthermore, the average AoI is shown to decrease considerably with the addition of more servers to the system.

The Model Context Protocol (MCP) is the dominant way coding agents discover and invoke external tools. A server advertises each tool through a tools/list handshake that returns a name, a natural-language description, and a JSON input schema. The client renders this metadata once, in a one-time approval dialog, and then injects it verbatim into the model's context on every subsequent turn. Nothing in the protocol requires the rendered approval view and the bytes delivered to the model to match. We isolate that gap as a single structural mechanism, concealment encoding, and show with a model-free, protocol-free analysis that Unicode's TAG block (U+E0000 to U+E007F) has no assigned glyph in any mainstream terminal, chat, or IDE renderer, so a payload written in it is absent from what a human reviewer sees while surviving byte-for-byte into the model's tokenizer. We then measure whether this mechanism actually defeats today's client-side defenses, building a proof-of-concept that speaks the real MCP JSON-RPC/stdio protocol against a genuine client and server. Across 5 distinct MCP metadata surfaces we implement 8 concrete techniques with a deterministic, protocol-level harness. All 8/8

Traditional tennis rating systems (e.g., Elo) summarize overall player strength but do not isolate the independent value of serving. Using point-by-point data from Wimbledon and the U.S.\ Open, we develop serve-specific player metrics that separate serving quality from return ability and other latent factors. For each tournament and gender, we fit logistic mixed-effects models of point outcomes using serve speed, speed variability, and placement features, with crossed server and returner random intercepts to capture unobserved player strengths. From these models we derive Server Quality Scores (SQS): partially pooled, opponent-adjusted estimates of players' serving impact. In out-of-sample evaluation, SQS aligns more strongly with serve efficiency$\unicode{x2014}$the probability of winning points within three shots$\unicode{x2014}$than weighted Elo. We further benchmark SQS against task-aligned serve-stat baselines and model ablations, quantifying the incremental value of serve features and partial pooling. Associations with overall serve win percentage are smaller and dataset-dependent, and neither SQS nor weighted Elo consistently dominates that outcome. Overall, SQS is best inte

We introduce the Kimina Lean Server, an open-source project designed as a high-performance verifier for reinforcement learning pipelines. Built on top of the Lean REPL (Read-Eval-Print Loop) maintained by the Lean FRO, our server combines server-side parallelism by managing multiple Lean processes in parallel with a Least Recently Used (LRU) caching mechanism that reuses Lean imports across requests. On the client side, a lightweight Python package enables submitting proof batches and receiving Lean feedback, including extracted tactics and tactic states. Together, these features enable a scalable workflow for large-scale verification and data extraction. In our experiments, the Kimina Lean Server outperforms previous Lean interaction tools, achieving a 1.5 to 2 times speedup in verification time. Moreover, its improved efficiency has enabled its use in the large-scale training of state-of-the-art models such as Kimina-Prover. We hope that our open-source project will support the neural theorem proving community and accelerate future progress by enabling efficient large-scale verification and proof data extraction.

We study a variant of the $k$-server problem, the infinite server problem, in which infinitely many servers reside initially at a particular point of the metric space and serve a sequence of requests. In the framework of competitive analysis, we show a surprisingly tight connection between this problem and the $(h,k)$-server problem, in which an online algorithm with $k$ servers competes against an offline algorithm with $h$ servers. Specifically, we show that the infinite server problem has bounded competitive ratio if and only if the $(h,k)$-server problem has bounded competitive ratio for some $k=O(h)$. We give a lower bound of $3.146$ for the competitive ratio of the infinite server problem, which implies the same lower bound for the $(h,k)$-server problem even when $k/h \to \infty$ and holds also for the line metric; the previous known bounds were 2.4 for general metric spaces and 2 for the line. For weighted trees and layered graphs we obtain upper bounds, although they depend on the depth. Of particular interest is the infinite server problem on the line, which we show to be equivalent to the seemingly easier case in which all requests are in a fixed bounded interval away fr

In this paper, we propose a server structure proposal and automatic performance verification technology which proposes and verifies an appropriate server structure on Infrastructure as a Service (IaaS) cloud with baremetal servers, container based virtual servers and virtual machines. Recently, cloud services have been progressed and providers provide not only virtual machines but also baremetal servers and container based virtual servers. However, users need to design an appropriate server structure for their requirements based on 3 types quantitative performances and users need much technical knowledge to optimize their system performances. Therefore, we study a technology which satisfies users' performance requirements on these 3 types IaaS cloud. Firstly, we measure performances of a baremetal server, Docker containers, KVM (Kernel based Virtual Machine) virtual machines on OpenStack with virtual server number changing. Secondly, we propose a server structure proposal technology based on the measured quantitative data. A server structure proposal technology receives an abstract template of OpenStack Heat and function/performance requirements and then creates a concrete template

Reference lists in scholarly manuscripts frequently contain errors, including incorrect identifiers, incomplete metadata, misattributed authors, and mismatches between preprint and published versions. These problems are tedious to repair manually and have become more visible in workflows that rely on large language models, which can fabricate or corrupt citations. We present citecheck, a TypeScript system and MCP server for automated bibliographic verification and repair in paper-like project folders. Given a manuscript file or workspace, citecheck selects the most likely paper artifact, extracts references from .bib, .tex, .md, .txt, or .docx, validates entries against PubMed, Crossref, arXiv, and Semantic Scholar, and returns structured correction proposals together with replacement-safety diagnostics. The current repository provides a working research prototype with multi-pass retrieval, manifestation-aware matching, policy-gated rewrite planning, and 47 passing tests covering repair behavior, malformed payload handling, transport failures, and MCP exposure. We position citecheck as infrastructure for agentic scholarly editing and as a practical guardrail against both traditiona

Because quantum computers are expensive, it is envisaged that individuals who want to utilize them would do so by delegating their calculations to someone who has a quantum computer. When quantum computer users delegate computations to quantum servers, they wish to keep information about their calculations hidden from the servers. The protocol of delegating a calculation while hiding information about the calculation from the server is called {\sl blind quantum computation protocol}. Prior research on single-server's blind quantum computation protocol required users to have quantum capabilities. Prior research on multiple-servers' blind quantum computation protocols required users to have just classical capabilities but imposed limits on the server-to-server communication. There are no known single-server blind quantum computation protocols with a classical user and multiple-servers blind quantum computation protocols that allows servers to communicate freely with each other. We show that the existence of these protocols is equivalence.

We study the steady-state performance of parallel-server systems under an immediate routing architecture with two sources of heterogeneity: servers and job classes, subject to compatibility constraints. We focus on the weighted-workload-task-allocation (WWTA) policy, a load-balancing scheme known to be throughput-optimal for such systems. Under a relaxed complete-resource-pooling (CRP) condition, we prove a "strong form" of state-space collapse in heavy traffic and that the scaled workload of each server converges in distribution to an exponential random variable, whose parameter is explicitly given by system primitives. Our analysis yields three main insights. First, the conventional heavy-traffic requirement of a unique static allocation plan can be dropped; a relaxed CRP condition suffices. Second, the limiting workload distribution is shown to be independent of local scheduling policy on server side, allowing substantial flexibility. Third, the inefficient (non-basic) activities prescribed by static allocation plan is proved to receive an asymptotically negligible fraction of routing and service, even though WWTA has no prior knowledge of which activities are basic, highlightin

We consider a discrete-time system comprising a first-come-first-served queue, a non-preemptive server, and a scheduler that governs the assignment of tasks in the queue to the server. The server has an availability state that indicates, at each instant, whether the server is busy working on a task or is available. In the latter case, if the queue is nonempty, then a task-assignment control policy implemented by the scheduler either assigns a new task to the server or allows it to rest. The server also has an integer-valued activity state that is non-increasing during rest periods, and is non-decreasing otherwise. An instantaneous service rate function ascribes to each possible value of the activity state a probability that the server can complete a task in one time step. For a typical instantaneous service rate function, the completion probability decreases (server performance worsens) as the activity state increases. The scheduler policy has access to the queue size and the entire state of the server. In this article, we study the problem of designing scheduler policies that stabilize the queue. We show that stability, whenever viable, can be achieved by a simple policy that base