waashk/dblp huggingface dataset:
opening the source repository with anonymous cvs. anonymous cvs is an advanced source file distribution mechanism we created to allow open source software projects to distribute source code and information about code to internet users. built on top of the concurrent versions system (cvs) revision control system, anonymous cvs safely allows anonymous read-only access to a cvs source repository. prior to the introduction of anonymous cvs, access to a cvs repository had to be restricted to a select group of privileged software developers. the advantage of open source software is that it promotes reliability and quality by allowing independent peer review and rapid evolution of source code. by introducing anonymous cvs, we have extended the concept of open source software projects to open source repository projects. having an open source repository allows users to take a more active role in the debugging and development of open source projects. in this paper we will examine and compare the mechanisms used by open source projects to distribute source code. we will present the design and implementation of the first anonymous cvs server (used to distribute the openbsd operating system). we will explain some of our concerns (e.g., security) and some of the problems we faced when trying to adapt cvs for anonymous use. we also will present other more recent source file distribution mechanisms that make use of an open cvs repository. anonymous cvs is currently bring used by a number of projects including openbsd, freebsd, mozilla, ecgs, gnome, python, and gnustep.
profiling and tracing dynamic library usage via interposition. run-time resolution of library functions provides a rich and powerful opportunity to collect workload profiles and function/parameter trace information without source, special compilation, or special linking. this can be accomplished by having the linker resolve library functions to special wrapper functions that collect statistics before and after calling the real library function, leaving both the application and real library unaltered. the set of dynamic libraries is quite large including interesting libraries like libc (the c library and operating system interface), graphics, database, network interface, and many more. coupling this with the ability to simultaneously trace multiple processes on multiple processors covering both client and server processes yields tremendous feedback. we have found the amount of detailed information that can be gathered has been useful in many stages of the project life-cycle including the design, development, tuning, and sustaining of hardware, libraries, and applications. this paper first contrasts our extended view of interposition to other profiling, tracing, and interposing techniques. this is followed by a description and sample output of tools developed around this view; a discussion of obstacles encountered developing the tools; and finally, a discussion of anticipated and unanticipated ways those tools have been applied.
linking programs in a single address space. linking and loading are the final steps in preparing a program for execution. this paper assesses issues concerning dynamic and static linking in traditional as well as single-address-space operating systems (sasos). related loading issues are also addressed. we present the dynamic linking model implemented in the mungi sasos and discuss its strengths and limitations. benchmarking shows that dynamic linking in a sasos carries significantly less overhead than dynamic linking in sgi's irix operating system. the same performance advantages could be achieved in unix systems, if they reserved a portion of the address space for dynamically linked libraries, and ensured that each library is always mapped at the same address.
a network positioning system for the internet. network positioning has recently been demonstrated to be a viable concept to represent the network distance relationships among internet end hosts. several subsequent studies have examined the potential benefits of using network position in applications, and proposed alternative network positioning algorithms. in this paper, we study the problem of designing and building a network positioning system (nps). we identify several key system-building issues such as the consistency, adaptivity and stability of host network positions over time. we propose a hierarchical network positioning architecture that maintains consistency while enabling decentralization, a set of adaptive decentralized algorithms to compute and maintain accurate, stable network positions, and finally present a prototype system deployed on planetlab nodes that can be used by a variety of applications. we believe our system is a viable first step to provide a network positioning capability in the internet.
the region trap library: handling traps on application-defined regions of memory. user-level virtual memory (vm) primitives are used in many different application domains including distributed shared memory, persistent objects, garbage collection, and checkpointing. unfortunately, vm primitives only allow traps to be handled at the granularity of fixed-sized pages defined by the operating system and architecture. in many cases, this results in a size mismatch between pages and application-defined objects that can lead to a significant loss in performance. in this paper we describe the design and implementation of a library that provides, at the granularity of application-defined regions, the same set of services that are commonly available at a page-granularity using vm primitives. applications that employ the interface of this library, called the region trap library (rtl), can create and use multiple objects with different levels of protection (i.e., invalid, read-only, or read-write) that reside on the same virtual memory page and trap only on read/write references to objects in an invalid state or write references to objects in a read-only state. all other references to these objects proceed at hardware speeds. benchmarks of an implementation on five different os/architecture combinations are presented along with a case study using region trapping within a distributed shared memory (dsm) system, to implement a region-based version of the lazy release consistency (lrc) coherence protocol. together, the benchmark results and the dsm case study suggest that region trapping mechanisms provide a feasible region-granularity alternative for application domains that commonly rely on page-based virtual memory primitives.
the old man and the c. "you can't teach an old dog new tricks" goes the old proverb. this is a story about a pack of old dogs (c programmers) and their odyssey of trying to learn new tricks (c++ programming). c++ is a large, complex language which can easily be abused, but also includes many features to help programmers more quickly write higher quality code. the teamware group consciously decided which c++ features to use and, just as importantly, which features not to use. we also incrementally adopted those features we chose to use. this resulted in a successful c++ experience.
towards availability benchmarks: a case study of software raid systems. benchmarks have historically played a key role in guiding the progress of computer science systems research and development, but have traditionally neglected the areas of availability, maintainability, and evolutionary growth, areas that have recently become critically important in high-end system design. as a first step in addressing this deficiency, we introduce a general methodology for benchmarking the availability of computer systems. our methodology uses fault injection to provoke situations where availability may be compromised, leverages existing performance benchmarks for workload generation and data collection, and can produce results in both detail-rich graphical presentations or in distilled numerical summaries. we apply the methodology to measure the availability of the software raid systems shipped with linux, solaris 7 server, and windows 2000 server, and find that the methodology is powerful enough not only to quantify the impact of various failure conditions on the availability of these systems, but also to unearth their design philosophies with respect to transient errors and recovery policy.
undo for operators: building an undoable e-mail store. system operators play a critical role in maintaining server dependability yet lack powerful tools to help them do so. to help address this unfulfilled need, we describe operator undo, a tool that provides a forgiving operations environment by allowing operators to recover from their own mistakes, from unanticipated software problems, and from intentional or accidental data corruption. operator undo starts by intercepting and logging user interactions with a network service before they enter the system, creating a record of user intent. during an undo cycle, all system hard state is physically rewound, allowing the operator to perform arbitrary repairs; after repairs are complete, lost user data is reintegrated into the repaired system by replaying the logged user interactions while tracking and compensating for any resulting externally-visible inconsistencies. we describe the design and implementation of an application-neutral framework for operator undo, and detail the process by which we instantiated the framework in the form of an undo-capable e-mail store supporting smtp mail delivery and imap mail retrieval. our proof-of-concept e-mail implementation imposes only a small performance overhead, and can store days or weeks of recovery log on a single disk.
retrofitting quality of service into a time-sharing operating system. theoretical aspects of proportional share schedulers have received considerable attention recently. we contribute practical considerations on how to retrofit such schedulers into mainstream time-sharing systems. in particular, we propose /reserv, a uniform api for hierarchical proportional resource sharing. the central idea in /reserv is associating resource reservations with references to shared objects (and not with the objects themselves). we discuss in detail the implementation of /reserv and several proportional share schedulers on freebsd; the modified system is called eclipse/bsd. our experiments demonstrate that the proposed modifications allow selected applications to isolate their (or their clients') performance from cpu, disk, or network overloads caused by other applications. this capability is increasingly important for soft real-time, multimedia, web, and distributed client-server applications.
multihoming performance benefits: an experimental evaluation of practical enterprise strategies. multihoming is increasingly being employed by large enterprises and data centers as a mechanism to extract good performance from their provider connections. today, multihomed end-networks can employ a variety of commercial route control products to optimize performance over multiple isp links. however, little is known about the mechanisms employed by such products and their relative trade-offs. in this paper, we propose and evaluate a wide range practical schemes that could go into the design of a route control device and analyze their trade-offs. we implement the proposed schemes on a linux-based web proxy and perform a trace-based emulation of their relative performance benefits. we show that both passive and active monitoring based techniques are equally effective and could improve web performance by about 25% when compared to using a single provider. another key observation is that the conventional practice of employing historical measurement samples to monitor and predict isp performance could, in fact, result in sub-optimal performance.
signaled receiver processing. protocol processing of received packets in bsd unix is interrupt-driven and may cause scheduling anomalies that are unacceptable in systems that provide quality of service (qos) guarantees. we propose an alternative mechanism, signaled receiver processing (srp), that generates a signal to the receiving process when a packet arrives. the default action of this signal is to perform protocol processing asynchronously. however, a receiving process may catch, block, or ignore the signal and defer protocol processing until a subsequent receive call. in any case, protocol processing occurs in the context of the receiving process and is correctly charged. therefore, srp allows the system to enforce and honor qos guarantees. srp offers several advantages over lazy receiver processing (lrp), a previous solution to bsd's scheduling anomalies: srp is easily portable to systems that support neither kernel threads nor resource containers (e.g., freebsd); gives applications control over the scheduling of protocol processing; uses a demultiplexing strategy that is appropriate for both hosts and gateways; and easily enables real-time or proportional-share scheduling.
adaptive block rearrangement under unix. an adaptive unix disk device driver is described. the driver copies frequently-referenced blocks from their original locations to reserved space near the center of the disk to reduce seek times. reference frequencies need not be known in advance. instead, they are estimated by monitoring the stream of arriving requests. measurements show that the adaptive driver reduces seek times by more than half, and improves response times significantly.
an efficient kernel-based implementation of posix threads. this paper describes the kernel-based implementation of posix threads (pthreads) in the dg/uxtm operating system. the implementation achieves time efficiency by using a general-purpose trap mechanism, known as a kernel function call (kfc), that carries an order of magnitude less overhead than a traditional system call. on a 50 mhz motorola mc88110, the implementation can create and exit a thread (with the associated context switch) in 8.1 microseconds and yield to another thread in 4.0 microseconds. the implementation also achieves space efficiency by paging and decoupling bulky data structures. the advantages of a kernel-based implementation include design simplicity, less code redundancy, optimization of global (interprocess) operations, avoidance of inopportune preemption, and global semantic flexibility. the disadvantage is a monolithic design that lacks user-level flexibility.
exploiting multiple i/o streams to provide high data-rates. we present an i/o architecture, called swift, that addresses the problem of data-rate mismatches between the requirements of an application, the maximum data-rate of the storage devices, and the 6ata-rate of the interconnection medium. the goal of swift is to support integrated continuous multimedia in general purpose distributed systems. in installations with a high-speed interconnection medium, swift will provide high data-rate transfers by using multiple slower storage devices in parallel. the data-rates obtained with this approach scale well when using multiple storage devices and multiple interconnections. swift has the flexibility to use any appropriate storage technology, including disk arrays. the ability to adapt to technological advances will allow swift to provide for ever increasing i/o demands. to address the problem of partial failures, swift stores data redundantly. using the unix operating system, we have constructed a simplified prototype of the swift architecture. using a single ethernet-based local-area network and three servers, the prototype provides data-rates that are almost three times as fast as access to the local scsi disk in the case of writes. when compared to nfs, the swift prototype provides double the data-rate for reads and eight times the data-rate for writes. the data-rate of our prototype scales almost linearly in the number of servers and the number of network segments. its performance is shown to be limited by the speed of the ethernet-based local-area network. we also constructed a simulation model to show how the swift architecture can exploit storage, communication, and processor advances, and to locate the components that will limit i/o performance. in a simulated gigabit/second token ring local-area network the data-rates are seen to scale proportionally to the size of the transfer unit and to the number of storage agents.
dynamic function placement for data-intensive cluster computing. optimally partitioning application and filesystem functionality within a cluster of clients and servers is a difficult problem due to dynamic variations in application behavior, resource availability, and workload mixes. this paper presents abacus, a run-time system that monitors and dynamically changes function placement for applications that manipulate large data sets. several examples of data-intensive workloads are used to show the importance of proper function placement and its dependence on dynamic run-time characteristics, with performance differences frequently reaching 2-10x. we evaluate how well the abacus prototype adapts to run-time system behavior, including both long-term variation (e.g., filter selectivity) and short-term variation (e.g., multi-phase applications and interapplication resource contention). our experiments with abacus indicate that it is possible to adapt in all of these situations and that the adaptation converges most quickly in those cases where the performance impact is most significant.
flipc: a low latency messaging system for distributed real time environments. flipc is a new messaging system intended to support distributed real time applications on high performance communication hardware. application messaging systems designed for high performance computing environments are not well suited to other environments because they lack support for the complex application structures involving multiple processes, threads, and classes of message traffic found in environments such as distributed real time. these messaging systems also have not been optimized for medium size messages found in important classes of real time applications. flipc includes additional features to support applications outside the high performance computing domain. for medium size messages, our system significantly outperforms other messaging systems on the intel paragon. an explicit design focus on programmable communication hardware and the resulting use of wait-free synchronization was a key factor in achieving this level of performance. the implementation of flipc was accelerated by our use of pc clusters connected by ethernet or by a scsi bus as development platforms to reduce the need for paragon time.
an application-aware data storage model. we describe a new application-controlled file persistence model in which applications select the desired stability from a range of persistence guarantees. this new abstraction extends conventional abstractions by allowing applications to specify a file's volatility and methods for automatic reconstruction in case of loss. the model allows applications, particularly ones with weak persistence requirements, to leverage the memory space of other machines to improve their performance. an automated (filename-matching) interface permits legacy applications to take advantage of the variable persistence guarantees without being modified. our prototype implementation shows significant speed-ups, in some cases more than an order of magnitude over conventional network file systems such as nfs version 3.
the autofs automounter. prior to the introduction of the automounter in 1987, nfs mounts were administered separately on each workstation. the automounter has provided administrators with a tool to construct a filesystem namespace that can be shared across an organization. while the automounter is widely used, its success has been tempered by problems inherent in its implementation. this paper describes a new implementation of the automounter based on a new filesystem. this new automounter not only fixes the problems, but provides some interesting opportunities for future development.
high performance x servers in the kdrive architecture. the common usage patterns of 2d drivers for the x window system have changed over time. new extensions such as render and composite are creating new demands for 2d rendering which do not match those for previous architectures tailored to the core protocol. this paper describes changes made to the kdrive x server implementation to implement new 2d acceleration, improve management of offscreen memory, implement opengl, and implement xvideo in a manner compatible with the composite extension. with these changes, kdrive is far better suited as a desktop x server than before and may serve as an example for desktop x server implementations. simple benchmarks are presented.
cut-and-paste file-systems: integrating simulators and file-systems. we have implemented an integrated and configurable file system called the pegasus fie-systems (pfs) and a trace-driven file-system simulator called patsy. patsy is used for off-line analysis of file-system algorithms, pfs is used for on-line file-system data storage. algorithms are first analyzed in patsy and when we are satisfied with the performance results, migrated into pfs for on-line usage. since patsy and pfs are derived from a common cut-and-paste filesystem framework, this migration proceeds smoothly. we have found this integration quite useful: algorithm bottlenecks have been found through patsy that could have led to performance degradations in pfs. off-line simulators are simpler to analyze compared to on-line file-systems because a work load can repeatedly be replayed on the same off-line simulator. this is almost impossible in on-line filesystems since it is hard to provide similar conditions for each experiment run. since simulator and file-system are integrated (hence, use the same code), experiment results from the simulator have relevance in the real system. this paper describes the cut-and-paste framework, the instantiation of the framework to pfs and patsy and finally, some of the experiments we conducted in patsy.
human computation. tasks like image recognition are trivial for humans, but continue to challenge even the most sophisticated computer programs. this talk discusses a paradigm for utilizing human processing power to solve problems that computers cannot yet solve. traditional approaches to solving such problems focus on improving software. i advocate a novel approach: constructively channel human brainpower using computer games. for example, the esp game, described in this talk, is an enjoyable online game - many people play over 40 hours a week - and when people play, they help label images on the web with descriptive keywords. these keywords can be used to significantly improve the accuracy of image search. people play the game not because they want to help, but because they enjoy it.
webmin: a web-based system administration tool for unix. this paper describes the design and implementation of the unix administration tool webmin, available from http://www.webmin.com/webmin/. webmin allows moderately experienced users to manage their unix system through a web browser interface, instead of editing configuration files directly. the most recent version supports apache, squid, bind, samba and many other servers and services. it supports multiple operating systems and distributions, different languages, multiple users each with different levels of access, and ssl encryption. the first part of the paper explains why webmin was developed and the initial design goals, and compares the design to other similar tools such as linuxconf. subsequent sections cover the design and implementation of the detailed multi-user security model, the implementation of webmin itself, how support for multiple operating systems is handled and how internationalization works. finally, two webmin modules are discussed in more detail and various problems explained before the conclusion.