waashk/dblp huggingface dataset:
efficient packet demultiplexing for multiple endpoints and large messages. this paper describes a new packet filter mechanism that efficiently dispatches incoming network packets to one of multiple endpoints, for example address spaces. earlier packet filter systems iteratively applied each installed filter against every incoming packet, resulting in high processing overhead whenever multiple filters existed. our new packet filter provides an associative match function that enables similar but not identical filters to be combined together into a single filter. the filter mechanism, which we call the mach packet filter (mpf), has been implemented for the mach 3.0 operating system and is being used to support endpoint-based protocol processing, whereby each address space implements its own suite of network protocols. with large numbers of registered endpoints, mpf outperforms the earlier bsd packet filter (bpf) by over a factor of four. mpf also allows a filter program to dispatch fragmented packets, which was quite difficult with previous filter mechanisms.
extending file systems using stackable templates. extending file system functionality is not a new idea, but a desirable one nonetheless[6, 14, 18]. in the several years since stackable file systems were first proposed, only a handful are in use[12, 19]. impediments to writing new file systems include the complexity of operating systems, the difficulty of writing kernel-based code, the lack of a true stackable vnode interface[14], and the challenges of porting one file system to another operating system. we advocate writing new stackable file systems as kernel modules. as a starting point, we propose a portable, stackable template file system we call wrapfs (wrapper file system). wrapfs is a canonical, minimal stackable file system that can be used as a pattern across a wide range of operating systems and file systems. given wrapfs, developers can add or modify only that which is necessary to achieve the desired functionality. wrapfs takes care of the rest, and frees developers from the details of operating systems. wrapfs templates exist for several common operating systems (solaris, linux, and freebsd), thus alleviating portability concerns. wrapfs can be ported to any operating system with a vnode interface that provides a private data pointer for each data structure used in the interface. the overhead imposed by wrapfs is only 5-7%. this paper describes the design and implementation of wrapfs, explores portability issues, and shows how the implementation was achieved without changing client file systems or operating systems. we discuss several examples of file systems written using wrapfs.
discovery and hot replacement of replicated read-only file systems, with application to mobile computing. we describe a mechanism for replacing files, including open files, of a read-only file system while the file system remains mounted; the act of replacement is transparent to the user. such a "hot replacement" mechanism can improve fault-tolerance, performance, or both. our mechanism monitors, from the client side, the latency of operations directed at each file system. when latency degrades, the client automatically seeks a replacement file system that is equivalent to but hopefully faster than the current file system. the files in the replacement file system then take the place of those in the current file system. this work has particular relevance to mobile computers, which in some cases might move over a wide area. wide area movement can be expected to lead to highly variable response time, and give rise to three sorts of problems: increased latency, increased failures, and decreased scalability. if a mobile client moves through regions having partial replicas of common file systems, then the mobile client can depend on our mechanism to provide increased fault tolerance and more uniform performance.
fist: a language for stackable file systems. traditional file system development is difficult. stackable file systems promise to ease the development of file systems by offering a mechanism for incremental development. unfortunately, existing methods often require writing complex low-level kernel code that is specific to a single operating system platform and also difficult to port. we propose a new language, fist, to describe stackable file systems. fist uses operations common to file system interfaces. from a single description, fist's compiler produces file system modules for multiple platforms. the generated code handles many kernel details, freeing developers to concentrate on the main issues of their file systems. this paper describes the design, implementation, and evaluation of fist. we extended file system functionality in a portable way without changing existing kernels. we built several file systems using fist on solaris, freebsd, and linux. our experiences with these examples shows the following benefits of fist: average code size over other stackable file systems is reduced ten × average development time is reduced seven × performance overhead of stacking is 1-2%.
a new approach to distributed memory management in the mach microkernel. in this paper we describe a new approach towards extending mach virtual memory semantics across the node boundaries of a multicomputer system. at its core, the advanced shared virtual memory (asvm) system employs algorithms from the realm of shared virtual memory that were adapted and extended to create a system that is efficient and scalable and supports full vm semantics, paging between node memories and efficient execution of svm applications. our performance measurements demonstrate asvm's superior efficiency and scalability compared to its predecessor, the extended memory manager (xmm) that is part of the mach kernel's norma distribution.
currentcy: a unifying abstraction for expressing energy management policies. the global nature of energy creates challenges and opportunities for developing operating system policies to effectively manage energy consumption in battery-powered mobile/wireless devices. the proposed currentcy model creates the framework for the operating system to manage energy as a first-class resource. furthermore, currentcy provides a powerful mechanism to formulate energy goals and to unify resource management policies across diverse competing applications and spanning device components with very different power characteristics. this paper explores the ability of the currentcy model to capture more complex interactions and to express more mature energy goals than previously considered. we carry out this exploration in ecosystem, an "energy-centric" linux-based operating system. we extend ecosystem to address four new goals: 1) reducing residual battery capacity at the end of the targeted battery lifetime when it is no longer required (e.g., recharging is available), 2) dynamic tracking of the energy needs of competing applications for more effective energy sharing, 3) reducing response time variation caused by limited energy availability, and 4) energy efficient disk management. our results show that the currentcy model can express complex energy-related goals and behaviors, leading to more effective, unified management policies than those that develop from per-device approaches.
a transport layer approach for improving end-to-end performance and robustness using redundant paths. recent work on internet measurement and overlay networks has shown that redundant paths are common between pairs of hosts and that one can often achieve better end-to-end performance by adaptively choosing an alternate path [8, 28]. in this paper, we propose an end-to-end transport layer protocol, mtcp, which can aggregate the available bandwidth of those redundant paths in parallel. by striping one flow's packets across multiple paths, mtcp can not only obtain higher end-to-end throughput but also become more robust under path failures. when some paths fail, mtcp can continue sending packets on other living paths and the recovery process normally takes only a few seconds. because mtcp could obtain an unfair share of bandwidth under shared congestion, we integrate a shared congestion detection mechanism into our system. it allows us to dynamically detect and suppress paths with shared congestion so as to alleviate the aggressiveness problem. mtcp can also passively monitor the performance of several paths in parallel and discover better paths than the path provided by the underlying routing infrastructure. we also propose a heuristic to find disjoint paths between pairs of nodes using traceroute. we have implemented our system on top of overlay networks and evaluated it in both planet-lab and emulab.
hyper-threading aware process scheduling heuristics. intel corporation's "hyper-threading technology" is the first commercial implementation of simultaneous multithreading. hyper-threading allows a single physical processor to execute two heavyweight threads (processes) at the same time, dynamically sharing processor resources. this dynamic sharing of resources, particularly caches, causes a wide variety of inter-thread behaviour. threads competing for the same resource can experience a low combined throughput. hyper-threads are abstracted by the hardware as logical processors. current generation operating systems are aware of the logical-physical processor hierarchy and are able to perform simple load-balancing. however, the particular resource requirements of the individual threads are not taken into account and sub-optimal schedules can arise and remain undetected. we present a method to incorporate knowledge of per-thread hyper-threading performance into a commodity scheduler through the use of hardware performance counters and the modification of dynamic priority.
implementing transparent shared memory on clusters using virtual machines. shared memory systems, such as smp and ccnuma topologies, simplify programming and administration. on the other hand, clusters of individual workstations are commonly used due to cost and scalability considerations. we have developed a virtual-machine-based solution, dubbed vnuma, that seeks to provide a numa-like environment on a commodity cluster, with a single operating system instance and transparent shared memory. in this paper we present the design of vnuma and some preliminary evaluation.
slinky: static linking reloaded. static linking has many advantages over dynamic linking. it is simple to understand, implement, and use. it ensures that an executable is self-contained and does not depend on a particular set of libraries during execution. as a consequence, the user executes exactly the same executable image as was tested by the developer, diminishing the risk that the user's environment will affect correct behavior. the major disadvantages of static linking are increases in the memory required to run an executable, network bandwidth to transfer it, and disk space to store it. in this paper we describe the slinky system that uses digest-based sharing to combine the simplicity of static linking with the space savings of dynamic linking: although slinky executables are completely self-contained, minimal performance and disk-space penalties are incurred if two executables use the same library. we have developed a slinky prototype that consists of tools for adding digests to executables, a slight modification of the linux kernel to use those digests to share code pages, and tools for transferring files between machines based on digests of their contents. results show that our prototype has no measurable performance decrease relative to dynamic linking, a comparable memory footprint, a 20% storage space increase, and a 34% increase in the network bandwidth required to transfer the packages. we believe that slinky obviates many of the justifications for dynamic linking, making static linking a superior technology for software organization and distribution.
a portable kernel abstraction for low-overhead ephemeral mapping management. modern operating systems create ephemeral virtual-to-physical mappings for a variety of purposes, ranging from the implementation of inter-process communication to the implementation of process tracing and debugging. with succeeding generations of processors the cost of creating ephemeral mappings is increasing, particularly when an ephemeral mapping is shared by multiple processors. to reduce the cost of ephemeral mapping management within an operating system kernel, we introduce the sf_buf ephemeral mapping interface. we demonstrate how in several kernel subsystems -- including pipes, memory disks, sockets, execve(), ptrace(), and the vnode pager -- the current implementation can be replaced by calls to the sf_buf interface. we describe the implementation of the sf_buf interface on the 32-bit i386 architecture and the 64-bit amd64 architecture. this implementation reduces the cost of ephemeral mapping management by reusing wherever possible existing virtual-to-physical address mappings. we evaluate the sf_buf interface for the pipe, memory disk and networking subsystems. our results show that these subsystems perform significantly better when using the sf_buf interface. on a multiprocessor platform interprocessor interrupts are greatly reduced in number or eliminated altogether.
a transactional flash file system for microcontrollers. we present a transactional file system for flash memory devices. the file system is designed for embedded microcontrollers that use an on-chip or on-board nor flash device as a persistent file store. the file system provides atomicity to arbitrary sequences of file system operations, including reads, writes, file creation and deletion, and so on. the file system supports multiple concurrent transactions. thanks to a sophisticated data structure, the file system is efficient in terms of read/write-operation counts, flash-storage overhead, and ram usage. in fact, the file system typically uses several hundreds bytes of ram (often less than 200) and a bounded stack (or no stack), allowing it to be used on many 16-bit microcontrollers. flash devices wear out; each block can only be erased a certain number of times. the file system manages the wear of blocks to avoid early wearing out of frequently-used blocks.
adaptive main memory compression. applications that use large data sets frequently exhibit poor performance because the size of their working set exceeds the real memory, causing excess page faults, and ultimately exhibit thrashing behavior. this paper describes a memory compression solution to this problem that adapts the allocation of real memory between uncompressed and compressed pages and also manages fragmentation without user involvement. the system manages its resources dynamically on the basis of the varying demands of each application and also on the situational requirements that are data dependent. the technique used to localize page fragments in the compressed area allows the system to reclaim or add space easily if it is advisable to shrink or grow the size of the compressed area. the design is implemented in linux, runs on both 32- bit and 64-bit architectures, and has been demonstrated to work in practice under complex workload conditions and memory pressure. the benefits from our approach depend on the relationship between the size of the compressed area, the application's compression ratio, and the access pattern of the application. for a range of benchmarks and applications, the system shows an increase in performance by a factor of 1.3 to 55.
thresher: an efficient storage manager for copy-on-write snapshots. a new generation of storage systems exploit decreasing storage costs to allow applications to take snapshots of past states and retain them for long durations. over time, current snapshot techniques can produce large volumes of snapshots. indiscriminately keeping all snapshots accessible is impractical, even if raw disk storage is cheap, because administering such large-volume storage is expensive over a long duration. moreover, not all snapshots are equally valuable. thresher is a new snapshot storage management system, based on novel copy-on-write snapshot techniques, that is the first to provide applications the ability to discriminate among snapshots efficiently. valuable snapshots can remain accessible or stored with faster access while less valuable snapshots are discarded or moved off-line. measurements of the thresher prototype indicate that the new techniques are efficient and scalable, imposing minimal (4%) performance penalty on expected common workloads.
privacy analysis for data sharing in *nix systems. linux and its various flavors (together called *nix) are growing in mainstream popularity and many enterprise infrastructures now are based on *nix platforms. an important component of these systems is the ingrained multi-user support that lets users share data with each other. in this paper, we analyze *nix systems and identify an urgent need for better privacy support in their data sharing mechanisms. in one of our studies it was possible to access over 84 gb of private data at one organization of 836 users, including over 300,000 emails and 579 passwords to financial and other private services websites. the most surprising aspect was the extremely low level of sophistication of the attack. the attack uses no technical vulnerabilities, rather inadequacies of *nix access control combined with user/application's privacy-indifferent behavior.
system- and application-level support for runtime hardware reconfiguration on soc platforms. this paper discusses the design and implementation of a system-level mechanism and corresponding application-level support that enables programs running on a reconfigurable soc to modify the underlying fpga at runtime. applications may request the addition and/or removal of softcore devices at any point in time. requests are handled in a coordinated way via a separate user-level process that fetches the configuration bistream from an exernal server. system reconfiguration is implemented via a fast suspend-resume mechanism with support for dynamic softcore device address management to achieve flexible device placement on the reconfigurable fabric. even though our approach does not rely on advanced (and expensive) hardware that supports dynamic partial reconfiguration, the obtained functionality is sufficient for a wide range of application scenarios.
reval: a tool for real-time evaluation of ddos mitigation strategies. there is a growing number of ddos attacks on the internet, resulting in significant impact on users. network operators today have little access to scientific means to effectively deal with these attacks in real time. the need of the hour is a tool to accurately assess the impact of attacks and more importantly identify feasible mitigation responses enabling real-time decision making. we designed and implemented reval, a tool that reports ddos attack impact in real time, scaling to large networks. this is achieved by modeling resource constraints of network elements and incorporating routing information. we demonstrate the usefulness of the tool on two real network topologies using empirical traffic data and examining real attack scenarios. using data from a tier-1 isp network (core, access and customer router network) of size in excess of 60000 nodes, reval models network conditions with close to 0.4 million traffic flows in about 11 seconds, and evaluates a given mitigation deployment chosen from a sample set in about 35 seconds. besides real-time decision support, we show how the simulator can also be used in longer term network planning to identify where and how to upgrade the network to improve network resilience. the tool is applicable for networks of any size and can be used to analyze other network anomalies like flash crowds.
interactive performance measurement with vncplay. today many system benchmarks use throughput as a measure of performance. while throughput is appropriate for benchmarking server environments, response time is a better metric for evaluating desktop performance. currently, there is a lack of good tools to measure interactive performance; although several commercial gui testing tools exist, they are not designed for performance measurement. this paper presents vncplay, a cross-platform tool for measuring interactive performance of gui-based systems. vncplay records a user's interactive session with a system and replays it multiple times under different system configurations; interactive response time is evaluated by comparing the times at which similar screen updates occur in each of the replayed sessions. using vncplay we studied the effect of processor speed and disk load on interactive performance of microsoft windows and linux. these experiments show that the same user session can have widely varying interactive response times in different environments while maintaining the same total running time, illustrating that response time is a better measure of interactive performance than throughput. the experimental results make a case for a response time measurement tool like vncplay.
smonitor: a non-intrusive client-perceived end-to-end performance monitor of secured internet services. end-to-end performance measurement is fundamental to building high-performance internet services. while many internet services often operate using http over ssl/tls, current monitors are limited to plaintext http services. this paper presents smonitor, a non-intrusive server-side end-to-end performance monitor that can monitor https services. the monitor passively collects live packet traces from a server site. it then uses a size-based analysis method on http requests to infer characteristics of client accesses and measures client-perceived pageview response time in real time. we designed and implemented a prototype of smonitor. preliminary evaluations show measurement error of less than 5%.
an evaluation of network stack parallelization strategies in modern operating systems. as technology trends push future microprocessors toward chip multiprocessor designs, operating system network stacks must be parallelized in order to keep pace with improvements in network bandwidth. there are two competing strategies for stack parallelization. message-parallel network stacks use concurrent threads to carry out network operations on independent messages (usually packets), whereas connection-parallel stacks map operations to groups of connections and permit concurrent processing on independent connection groups. connection-parallel stacks can use either locks or threads to serialize access to connection groups. this paper evaluates these parallel stack organizations using a modern operating system and chip multiprocessor hardware. compared to uniprocessor kernels, all parallel stack organizations incur additional locking overhead, cache inefficiencies, and scheduling overhead. however, the organizations balance these limitations differently, leading to variations in peak performance and connection scalability. lock-serialized connection-parallel organizations reduce the locking overhead of message-parallel organizations by using many connection groups and eliminate the expensive thread handoff mechanism of thread-serialized connection-parallel organizations. the resultant organization outperforms the others, delivering 5.4 gb/s of tcp throughput for most connection loads and providing a 126% throughput improvement versus a uniprocessor for the] heaviest connection loads.
how dns misnaming distorts internet topology mapping. network researchers commonly use reverse dns lookups of router names to provide geographic or topological information that would otherwise be difficult to obtain. by systematically examining a large isp, we find that some of these names are incorrect. we develop techniques to automatically identify these misnamings, and determine the actual locations, which we validate against the configuration of the isp's routers. while the actual number of misnamings is small, these errors induce a large number of false links in the inferred connectivity graph. we also measure the effects on path inflation, and find that the misnamings make path inflation and routing problems appear much worse than they actually are.