Searcharxiv⌕ Search
Home/Archive/arXiv

arXiv · cs/0502012

Sequential File Programming Patterns and Performance with .NET

Peter Kukol·Jim Gray
View original source ↗Read source document ↗Export metadata ↓

Abstract

Programming patterns for sequential file access in the .NET Framework are described and the performance is measured. The default behavior provides excellent performance on a single disk - 50 MBps both reading and writing. Using large request sizes and doing file pre-allocation when possible have quantifiable benefits. When one considers disk arrays, .NET unbuffered IO delivers 800 MBps on a 16-disk array, but buffered IO delivers about 12% of that performance. Consequently, high-performance file and database utilities are still forced to use unbuffered IO for maximum sequential performance. The report is accompanied by downloadable source code that demonstrates the concepts and code that was used to obtain these measurements.

Explore related subjects

cs.PFcs.OS

Keep this discovery

Explore connections, maps & timelines

BibTeXRIS

Peter Kukol, Jim Gray. 2005-02-02. Sequential File Programming Patterns and Performance with .NET. https://arxiv.org/abs/cs/0502012

Cite the original work for its findings. Save a collection to share your selection of sources.

KEEP EXPLORING

Related papers

arXiv2026

The Unreported Variable:Collector Selectivity in Data Placement Evaluation

A solid-state drive cannot overwrite data in place, so it cleans full blocks by copying out still-valid data, costing speed and lifetime. Interfaces such as NVMe Flexible Data Placement (FDP) let the host label data by expected lifetime so data dying together is stored together, and published schemes report cutting these copies by 20--75%. Those studies rarely state which blocks the drive chooses to clean. Varying only this choice in simulation, we show it decides how much a label is worth: label value peaks when the drive searches moderately for blocks holding little valid data, falls when it always takes the block with the least, and turns negative when it ignores how much valid data blocks hold. This holds in 47 of 48 synthetic configurations, and one real mail-server trace shows the same shape at about half the magnitude. Priced as spare capacity, a two-class label is worth 65% more spare when each scheme runs at its best setting, but becomes a net loss at 20% label error, typical of learned classifiers. Labels stating which data die together keep most of their value at 16 FDP handles and gain as cleaning improves. Evaluations must report the drive's cleaning policy.

cs.PF↗
arXiv2026

Warpline: Binary-Level Tracing and Unified Evidence for Agentic GPU Kernel Optimization

LLM agents are becoming GPU kernel engineers, but they still tune kernels without seeing where the time goes. Hardware profilers report how busy each unit was, not where each warp's time went; intra-kernel tracers can show it, but only with hand-placed probes and a recompilation that alters the very kernel being measured. We present Warpline, which gives agents this view automatically while leaving the kernel essentially unchanged. Warpline analyzes the binary to decide which events to record and inserts probes into the binary itself without recompilation or any manual step. It then aligns the trace with hardware profiling data on one unified timeline. Because it needs only the binary, it can regenerate this evidence for every new version of the kernel at whatever level the agent edits it (source, IR, or PTX), closing the optimization loop without human intervention. On NVIDIA B200, across 35 kernels in Triton, CuTe DSL, and CUDA C++, Warpline adds a median overhead of 1.2% and leaves a median 99.9% of executed instructions unchanged, whereas existing tracers have median overheads of 1.6% to 13.2% and leave only 4.6% to 32.7% unchanged. Warpline also traces closed-source kernels, which these tracers cannot. On 10 SOL-ExecBench problems, agents using Warpline spend less time and fewer model requests than a bare coding agent and NVIDIA's Kernel Design Agents (KDA), yet lead both after every round in geometric mean and reach a 7.69$\times$ geometric-mean speedup, against 6.94$\times$ and 6.13$\times$. Two case studies further demonstrate that Warpline reveals hidden bottlenecks and provides actionable optimization insights.

cs.PF↗
arXiv2026

Trustworthiness as a Measurement Structure for Task Conformance in 6G Service Chains

A 6G service crosses a chain of stages from different vendors, and its contract binds class-conditioned guarantees at the terminal interface: in the packet relay chain studied here, a priority class is owed a timely-delivery rate and a loss ceiling. We define trustworthiness as conformance of the delivered per-class distribution of outcomes to the contract and develop the measurement structure this forces. Two results fix its form: a discrepancy that treats outcomes interchangeably cannot express contract preferences, and no single expectation-valued score that determines the contracted terminal expectations can be carried from stage to stage once two or more contracted indicators remain independent at some stage. The minimal record is one signed number per independent contracted indicator, which the downstream design data carry to the terminal exactly; classical scalar trust models are the single-indicator case. The terminal deviation splits exactly into per-stage contributions. Transition logs at a stage estimate its contribution without reconstructing its full deployed behavior, a stage at its design behavior is flagged at most at a declared rate whatever traffic it receives, and the estimates bracket each stage's share of the terminal deviation at explicit confidence. In the three-relay chain, a relay that either deprioritizes premium traffic or has degraded capacity violates the same clause with identical contracted evidence: the transition audit localizes the relay in 300 of 300 windows and brackets its share of the deviation, and a diagnostic separates the causes.

cs.PF↗