focalinterest.net

Tag: Algorithms, Logic & Theory

  • Thoth improves prefetching for irregular memory access patterns

    What the study found

    Thoth, a hardware prefetcher, was reported to uncover data-dependent memory access (DDMA) patterns more robustly than prior approaches by working with explicit producer-consumer load pairs. The authors say it can handle multi-level range relations that earlier methods struggled to learn.

    Why the authors say this matters

    The authors argue that DDMA patterns are common in sparse data structures used in graph analytics, machine learning, and high-performance computing, and that missed prefetching opportunities can hurt memory performance. They conclude that Thoth helps address those limitations by reducing mismatches in sampled load instances and improving pattern discovery.

    What the researchers tested

    The researchers presented Thoth, which detects producer-consumer load pairs using register-level dependency tracking and then uses annotation-directed load sampling to sample only annotated load instances. They also used precise load annotation with reorder identifiers to handle pipeline flushes.

    What worked and what didn't

    On a suite of DDMA-intensive benchmarks, Thoth achieved a 51.1% speedup over a no-prefetching baseline. The abstract says it outperformed two state-of-the-art DDMA prefetchers by 14.7% and 8.2%, respectively, while prior address-based and instruction-based methods struggled with multi-level range relations, miscorrelation, mismatched load instances, or incomplete dependency chains.

    What to keep in mind

    The available summary does not describe benchmark details beyond stating that they were DDMA-intensive. It also does not provide limitations, overheads, or information about how the method performs outside the reported benchmark suite.

    • Thoth is a hardware prefetcher for data-dependent memory access patterns.
    • The method uses explicit producer-consumer load pairs instead of dependency chains.
    • Annotation-directed load sampling is used to sample only matched load instances.
    • On DDMA-intensive benchmarks, Thoth showed a 51.1% speedup over no prefetching.
    • Thoth outperformed two state-of-the-art DDMA prefetchers by 14.7% and 8.2%.

  • LoCaL reveals surface bias in code evaluation metrics

    What the study found

    The study found that four state-of-the-art reference-based code evaluation metrics can be strongly biased toward surface-level features instead of code functionality. It also found that these metrics perform significantly worse on LoCaL, a new benchmark designed to target cases where they are likely to do poorly.

    Why the authors say this matters

    The authors suggest that exposing code evaluation metrics to LoCaL-like data might help develop metrics that are robust to surface bias. They present this as relevant because reliable code evaluation metrics are described as crucial for progress in software engineering tasks.

    What the researchers tested

    The researchers critically evaluated four state-of-the-art reference-based code evaluation metrics, which score a candidate program by comparing it to a reference program. They also introduced LoCaL (Looks Can Lie), a benchmark with 3,117 code pairs at both the method and program levels, using differential fuzzing to assign functional similarity scores without predefined test cases.

    What worked and what didn't

    LoCaL includes code pairs that are surface-similar but functionally dissimilar, as well as pairs that are functionally similar but surface-dissimilar. The abstract says the functional similarity scores are made more reliable by executing an order of magnitude more tests than prior work. All four evaluated metrics showed significant performance degradation on LoCaL compared with baselines.

    What to keep in mind

    The abstract says prior datasets for these metrics rarely included the kinds of code pairs that LoCaL targets. It does not provide detailed limitations beyond this gap in existing evaluation data.

    • Four reference-based code evaluation metrics were found to favor surface-level similarity over functionality.
    • LoCaL is a benchmark of 3,117 code pairs at the method and program levels.
    • LoCaL uses differential fuzzing to compute functional similarity scores without predefined test cases.
    • All four evaluated metrics performed significantly worse on LoCaL than on baselines.
    • The authors suggest LoCaL-like data may help develop metrics that are less affected by surface bias.

  • GraphQLify converted REST APIs with zero type mismatches

    What the study found

    The study found that GraphQLify, an automated framework for moving REST APIs to GraphQL, could convert APIs while preserving end-to-end type safety. It also generated an embedded server that directly invokes API code rather than using a separate adapter server.

    Why the authors say this matters

    The authors say this matters because GraphQL is a schema-based, strongly typed query language that can support efficient client-server communication, and preserving type safety is described as a core advantage of adopting it. They also suggest that avoiding separate adapter servers matters because it removes performance overhead from dynamic request binding and network latency.

    What the researchers tested

    The researchers evaluated GraphQLify on 834 APIs from nine popular open-source projects. They compared it with OASGraph, the current state-of-the-art tool in the abstract, and also measured performance for workflows requiring five sequential API calls.

    What worked and what didn't

    GraphQLify successfully converted 100% of the tested APIs with zero type mismatches. By comparison, OASGraph had a 3.5% failure rate and a 42% type mismatch rate on the same dataset. For five sequential API calls, GraphQLify reduced data-fetching time by a factor of 2 to 4 versus REST.

    What to keep in mind

    The abstract does not describe limitations beyond the reported evaluation setting. The results are based on the specific set of 834 APIs from nine open-source projects and the performance test described in the abstract.

    • GraphQLify is an automated framework for migrating REST APIs to GraphQL.
    • It uses static source code analysis for type inference and generates an embedded server.
    • In the evaluation, it converted 100% of 834 APIs with zero type mismatches.
    • OASGraph had a 3.5% failure rate and a 42% type mismatch rate on the same dataset.
    • For five sequential API calls, GraphQLify cut data-fetching time by a factor of 2 to 4.

  • AgentBound secures MCP server execution boundaries

    What the study found

    The study found that AgentBound, an access control framework for Model Context Protocol (MCP) servers, can contain malicious behavior without requiring server modifications. The authors report that it can automatically generate access control policies from source code and enforce them with negligible overhead.

    Why the authors say this matters

    The authors conclude that AgentBound provides developers and project managers with a foundation for securing MCP servers while maintaining productivity. They also say it offers a basis for researchers and tool builders to explore declarative access control and MCP security.

    What the researchers tested

    The researchers introduced AgentBound, which combines a declarative policy mechanism inspired by the Android permission model with a policy enforcement engine. They built a dataset of the 296 most popular MCP servers and tested automatic policy generation from source code, threat blocking in several malicious MCP servers, and runtime overhead.

    What worked and what didn't

    The study reports that access control policies could be generated automatically from source code with 80.9% accuracy. It also reports that AgentBound blocked the majority of security threats in several malicious MCP servers and that the enforcement engine introduced negligible overhead.

    What to keep in mind

    The abstract does not provide detailed limitations beyond the tested dataset of 296 popular MCP servers and several malicious MCP servers. The summary available here does not describe which specific threats were blocked or where the policy generation was less accurate.

    • AgentBound is presented as the first access control framework for MCP servers.
    • It uses a declarative policy mechanism inspired by the Android permission model.
    • Automatic policy generation from source code reached 80.9% accuracy on the reported dataset.
    • The framework blocked the majority of threats in several malicious MCP servers.
    • The enforcement engine was reported to add negligible overhead.

  • Temporal-clique queries are evaluated more efficiently

    What the study found

    The study found that temporal-clique subgraph queries can be evaluated more efficiently when both the query's topology and time-window overlap are used together. The authors report that their approach outperforms existing techniques while adding minimal storage overhead.

    Why the authors say this matters

    The authors say this matters because temporal-clique subgraph pattern matching has applications in social networks, life sciences, smart cities, and telecommunications. They suggest that improving processing for queries with both temporal and structural constraints can make this kind of analysis more practical.

    What the researchers tested

    The researchers studied temporal-clique subgraph pattern matching, where edges must match a specific graph structure and also overlap within a specified time window. They proposed a new query-processing approach with a specialized multi-way join operator, an optimized query planner, and a cardinality estimator, plus additional optimizations.

    What worked and what didn't

    The approach was reported to better use both topological selectivity and temporal selectivity in the query. The experiments showed substantial performance gains over state-of-the-art methods, and the abstract says the method required minimal extra storage. Existing subgraph matching techniques were described as inefficient for these combined queries.

    What to keep in mind

    The abstract does not describe specific datasets, experimental settings, or detailed numerical results. It also does not provide limitations beyond noting that existing techniques are inefficient for these combined temporal and structural queries.

    • Temporal-clique subgraph queries combine structural graph matching with a time-window constraint.
    • The authors propose a new query-processing approach with a multi-way join operator, query planner, and cardinality estimator.
    • The paper reports substantial performance improvement over state-of-the-art techniques.
    • The method is described as requiring minimal additional storage overhead.
    • Applications mentioned include social networks, life sciences, smart cities, and telecommunications.

  • IntraCross improves intravascular sequence registration across imaging modalities

    What the study found

    The study found that IntraCross, a graph matching framework, can register intravascular sequences by learning partial matches between anatomical landmarks rather than forcing one-to-one frame alignment. The authors report that it aligns temporal and rotational information at the same time and rejects landmarks that cannot be matched.

    Why the authors say this matters

    The authors say this matters because intravascular ultrasound (IVUS) and optical coherence tomography (OCT) are complementary ways to assess atherosclerosis in vivo, and better registration may improve how these sequences are combined in clinical workflows. They also state that their method aligns with clinical workflows and may reduce problems caused by manual alignment and sequential registration steps.

    What the researchers tested

    The researchers developed IntraCross as a graph matching framework for intravascular sequence registration. They extended partial matching techniques from 2D to 3D sequences and added a temporal prior to regularize matching, then tested the approach in 77 vessels from 22 patients.

    What worked and what didn't

    In testing, the method showed high agreement with expert analysts, with a Williams Index of 1.1 and p-values of 0.62, 0.89, and 0.07. The abstract also says the approach outperformed existing methods reported in the literature for circumferential registration, with p-values of 0.01 and 0.04.

    What to keep in mind

    The abstract does not describe limitations in detail. It also does not provide full information about the comparison methods, the meaning of each reported p-value, or how generalizable the results are beyond the vessels and patients studied.

    • IntraCross learns partial landmark correspondences instead of forcing frame-by-frame matches.
    • The method registers temporal and rotational information together.
    • The study tested the approach in 77 vessels from 22 patients.
    • The abstract reports high agreement with expert analysts.
    • The abstract reports better circumferential registration than prior methods in the literature.

  • gRPC was fastest for large-scale reads; GraphQL and Thrift were faster for small data

    What the study found

    The study found different performance advantages for different web programming interfaces. gRPC, a remote procedure call system, was fastest for the shortest execution time in large-scale read operations, while GraphQL and Thrift were faster when operations returned small amounts of data.

    Why the authors say this matters

    The authors present the comparison as a way to evaluate technologies commonly used to implement web programming interfaces. The study suggests that performance choice may depend on the size of the data being transferred and the kind of operation performed.

    What the researchers tested

    The researchers developed three applications, each using one of the technologies: GraphQL, gRPC, and Thrift. They tested the applications with JMeter, a load-testing tool, and measured execution time and the amount of data returned during operations on a relational database.

    What worked and what didn't

    gRPC showed the shortest execution time for large-scale read operations. GraphQL and Thrift were faster for operations that transported small volumes of data.

    What to keep in mind

    The abstract does not describe additional limitations beyond the specific comparison tested here. The results are limited to the three applications, the relational database operations, and the testing setup described in the article.

    • The article compares GraphQL, gRPC, and Thrift.
    • gRPC was fastest for large-scale read operations.
    • GraphQL and Thrift were faster for small-volume data operations.
    • The applications were tested with JMeter.
    • Execution time and returned data volume were measured on a relational database.

  • WaSC decouples WebAssembly system access with low startup latency

    What the study found

    The study found that WaSC, a secure container runtime, hardens WebAssembly system isolation by decoupling the system interface into a virtualization-based daemon. The authors report that this preserves function-level startup time and memory use while protecting the system interface with machine-level isolation.

    Why the authors say this matters

    The authors say this matters because WebAssembly (WASM), a web standard for running code in a sandboxed environment, is emerging as an alternative to containers in serverless computing, but the WASM System Interface (WASI) does not guarantee isolation from the host kernel. The study suggests WaSC addresses that gap while keeping some of the efficiency advantages associated with WASM.

    What the researchers tested

    The researchers introduced WaSC and evaluated it with microbenchmarks and application benchmarks. They compared its performance with Firecracker, a secure container runtime, and examined startup latency, memory footprint, system interface call overhead, and application runtime behavior.

    What worked and what didn't

    WaSC achieved a 99th-percentile startup latency of 15 ms and a memory footprint of about 10 MB. Compared with Firecracker, it achieved 3× memory density on a single physical machine. The study also found a 3.2× slowdown for WASI calls along the virtualization-based daemon path, and SQLite speedtest1 showed an average 80% increase in runtime.

    What to keep in mind

    The abstract does not describe security limitations beyond noting that WASI does not guarantee isolation from the host kernel. It also does not provide details on which workloads were included beyond the mention of microbenchmarks, application benchmarks, and SQLite speedtest1.

    • WaSC hardens WebAssembly system isolation by moving the system interface into a virtualization-based daemon.
    • The authors report 15 ms 99th-percentile startup latency and about 10 MB memory footprint.
    • WaSC achieves 3× memory density compared with Firecracker on a single physical machine.
    • WASI calls through the daemon path are reported to slow down by 3.2×.
    • SQLite speedtest1 shows an average 80% increase in runtime.