waashk/dblp huggingface dataset:
open information pools. on the www it is not possible to supplement existing web pages of other people with new information or a link to that information, because the www does not have a standard method for write access. with write access, information can be added in the right context, which eases searching. we therefore define open information pools: a collection of www based databases with public write access. by using databases we add structure to the information. each database deals with a specific topic. we developed an architecture to support open information pools. important elements in the architecture are the rating and moderation tools. with these tools the user group is able to maintain and update the database and also to prevent errors and abuse. we conducted measurements on operational rating and moderation tools to show the validity of our idea. the study of slashdot.org's rating and moderation tools shows that insightful information is recognised after only 37 minutes. we implemented a prototype of a true open information pool containing music information. this database contains biographies, audio cd descriptions, audio cd cover pictures, lyrics of the songs with timing information, and midi files. we developed several tools to create, insert and search this database.
scalable network i/o in linux. recent highly publicized benchmarks have suggested that linux systems do not scale as well as other systems, such as windows nt, when used as network servers. windows nt contains features such as i/o completion ports that help boost network server performance and scalability. in this paper we focus on improving the linux implementation of poll() to reduce the expense of managing large numbers of network connections. we also explore the newer posix rt signal api that will help network servers scale into the next decade. a comparison between the two interfaces shows that a server using our /dev/poll interface scales better than a server using rt signals.
a future-adaptable password scheme. many authentication schemes depend on secret passwords. unfortunately, the length and randomness of user-chosen passwords remain fixed over time. in contrast, hardware improvements constantly give attackers increasing computational power. as a result, password schemes such as the traditional unix user-authentication system are failing with time. this paper discusses ways of building systems in which password security keeps up with hardware speeds. we formalize the properties desirable in a good password system, and show that the computational cost of any secure password scheme must increase as hardware improves. we present two algorithms with adaptable cost--eksblowfish, a block cipher with a purposefully expensive key schedule, and bcrypt, a related hash function. failing a major breakthrough in complexity theory, these algorithms should allow password-based systems to adapt to hardware improvements and remain secure well into the future.
a text retrieval package for the unix operating system. this paper describes lq-text, an inverted index text retrieval package written by the author. inverted index text retrieval provides a fast and effective way of searching large amounts of text. this is implemented by making an index to all of the natural-language words that occur in the text. the actual text remains unaltered in place, or, if desired, can be compressed or archived; the index allows rapid searching even if the data files have been altogether removed. the design and implementation of lq-text are discussed, and performance measurements are given for comparison with other text searching programs such as grep and agrep. the functionality provided is compared briefly with other packages such as glimpse and zbrowser. the lq-text package is available in source form, has been successfully integrated into a number of other systems and products, and is in use at over 100 sites.
cryptography in openbsd: an overview. cryptographic mechanisms are an important security component of an operating system in securing the system itself and its communication paths. indeed, in many situations, cryptography is the only tool that can solve a particular problem, e.g., network-level security. while cryptography by itself does not guarantee security, when applied correctly, it can significantly improve overall security. since one of the main foci of the openbsd system is security, various cryptographic mechanisms are employed in a number of different roles. this paper gives an overview of the cryptography employed in openbsd. we discuss the various components (ipsec, ssl libraries, stronger password encryption, kerberos iv, random number generators, etc.), their role in system security, and their interactions with the rest of the system (and, where applicable, the network).
trusted path execution for the linux 2.6 kernel as a linux security module. the prevention of damage caused to a system via malicious executables is a significant issue in the current state of security on linux operating systems. several approaches are available to solve such a problem at the application level of a system but very few are actually implemented into the kernel. the linux security module project was aimed at applying security to the linux kernel without imposing on the system. it performs this task by creating modules that could be loaded and unloaded onto the system on the fly and according to how the administrator would like to lock down their system. the trusted path execution (tpe) project was ported to the linux kernel as a linux security module (lsm) to create a barrier against such security issues from occurring. this paper will attempt to explain how trusted path execution is implemented in the linux kernel as an lsm. it will also describe how tpe can prevent the running of malicious code on a linux system via a strategically placed hook in the kernel. the usage of a pseudo-filesystem approach to creating an access control list for users on the system will also be discussed. the paper will further explain how tpe is designed and implemented in the kernel. this paper will show how the access control list is utilized by the module to place checks on the execution of code on the system along with a check of the path the code is being run in. further, the origins of the "trusted path" concept and its origination in the openbsd operating system will be discussed along with how tpe was introduced to the linux security community. the paper will conclude with a synopsis of the contents and future paths and goals of the project.
the new jersey machine-code toolkit. the new jersey machine-code toolkit helps programmers write applications that process machine code. applications that use the toolkit are written at an assembly-language level of abstraction, but they recognize and emit binary. guided by a short instruction-set specification, the toolkit generates all the bit-manipulating code. the toolkit's specification language uses four concepts: fields and tokens describe parts of instructions, patterns describe binary encodings of instructions or groups of instructions, and constructors map between the assembly-language and binary levels. these concepts are suitable for describing both cisc and risc machines; we have written specifications for the mips r3000, sparc, and intel 486 instruction sets. we have used the toolkit to help write two applications: a debugger and a linker. the toolkit generates efficient code; for example, the linker emits binary up to 15% faster than it emits assembly language, making it 1.7-2 times faster to produce an a.out directly than by using the assembler.
in-place rsync: file synchronization for mobile and wireless devices. the open-source rsync utility reduces the time and bandwidth required to update a file across a network. rsync uses an interactive protocol that detects changes in a file and sends only the changed data [18, 19]. we have modified rsync so that it operates on space constrained devices. files on the target host are updated in the same storage the current version of the file occupies. space-constrained devices cannot use traditional rsync because it requires memory or storage for both the old and new version of the file. examples include synchronizing files on cellular phones and handheld pcs, which have small memories. the in-place rsync algorithm encodes the compressed representation of a file in a graph, which is then topologically sorted to achieve the in-place property. we compare the performance of in-place rsync to rsync and conclude that in-place rsync degrades performance minimally.
resolving file conflicts in the ficus file system. ficus is a flexible replication facility with optimistic concurrency control designed to span a wide range of scales and network environments. optimistic concurrency control provides rapid local access and high availability of files for update in the face of disconnection, at the cost of occasional conflicts that are only discovered when the system is reconnected. ficus reliably detects all possible conflicts. many conflicts can be automatically resolved by recognizing the file type and understanding the file's semantics. this paper describes experiences with conflicts and automatic conflict resolution in ficus. it presents data on the frequency and character of conflicts in our environment. this paper also describes how semantically knowledgeable resolvers are designed and implemented, and discusses our experiences with their strengths and limitations. we conclude from our experience that optimistic concurrency works well in at least one realistic environment, conflicts are rare, and a large proportion of those conflicts that do occur can be automatically solved without human intervention.
virtual services: a new abstraction for server consolidation. modern server operating systems (os's) do not address the issue of interference between competing applications. this deficiency is a major road-block for internet and application service providers who want to multiplex server resources among their business clients. to insulate applications from each other, we introduce virtual services (vss). besides providing per-service resource budgets, vss drastically reduce cross-service interference in the presence of shared backend services, such as databases and name services. vss provide dynamic per-service resource partitioning and management in a manner completely transparent to applications. to accomplish this goal, we introduce a kernel-based work classification mechanism called gates. gates track work that propagates from one service to another and are configured by the system administrator via simple rules. they automate the binding of processes and sockets to vss, and ensure that any work done on behalf of a vs, even if it is done by shared services, is charged to the resource budget of the vs that requested it. using our experimental linux 2.0.36-based implementation we applied them effectively to co-hosted web servers. thus, nearly eliminating performance interference between the co-hosted sites.
a comparison of file system workloads. in this paper, we describe the collection and analysis of file system traces from a variety of different environments, including both unix and nt systems, clients and servers, and instructional and production systems. our goal is to understand how modern workloads affect the ability of file systems to provide high performance to users. because of the increasing gap between processor speed and disk latency, file system performance is largely determined by its disk behavior. therefore we primarily focus on the disk i/o aspects of the traces. we find that more processes access files via the memory-map interface than through the read interface. however, because many processes memory-map a small set of files, these files are likely to be cached. we also find that file access has a bimodal distribution pattern: some files are written repeatedly without being read; other files are almost exclusively read. we develop a new metric for measuring file lifetime that accounts for files that are never deleted. using this metric, we find that the average block lifetime for some workloads is significantly longer than the 30-second write delay used by many file systems. however, all workloads show lifetime locality: the same files tend to be overwritten multiple times.
permanent web publishing. lockss (lots of copies keep stuff safe) is a prototype of a system to preserve access to scientific journals published on the web. it is a majority-voting fault-tolerant system that, unlike normal systems, has far more replicas than would be required just to survive the anticipated failures. we are exploring techniques that exploit the surplus of replicas to permit a much looser form of coordination between them than conventional fault-tolerant technology would require.
making the "box" transparent: system call performance as a first-class result. for operating system intensive applications, the ability of designers to understand system call performance behavior is essential to achieving high performance. conventional performance tools, such as monitoring tools and profilers, collect and present their information off-line or via out-of-band channels. we believe that making this information first-class and exposing it to applications via in-band channels on a per-call basis presents opportunities for performance analysis and tuning not available via other mechanisms. furthermore, our approach provides direct feedback to applications on time spent in the kernel, resource contention, and time spent blocked, allowing them to immediately observe how their actions affect kernel behavior. not only does this approach provide greater transparency into the workings of the kernel, but it also allows applications to control how performance information is collected, filtered, and correlated with application-level events. to demonstrate the power of this approach, we show that our implementation, debox, obtains precise information about os behavior at low cost, and that it can be used in debugging and tuning application performance on complex workloads. in particular, we focus on the industry-standard specweb99 benchmark running on the flash web server. using debox, we are able to diagnose a series of problematic interactions between the server and the os. addressing these issues as well as other optimization opportunities generates an overall factor of four improvement in our specweb99 score, throughput gains on other benchmarks, and latency reductions ranging from a factor of 4 to 47.
design and implementation of a simulation library using lightweight processes. the \si/ lightweight-process based system for simulating process interactions is an enhancement to the c programming language in the form of library primitives with sets of predefined data structures. the \si/ system encapsulates an existing lightweight-process library to provide a discrete-event simulation environment supporting the process view. it was developed as a research testbed for investigating methods which support simulations efficiently. easy extensions and modifications to the \si/ system are a major design objective, accomplished through modularity and layering. this paper describes the system, our experiences with its implementation, and its applicability to simulation modeling. we report on performance measurements of different implementations of the simulation scheduler, and of different algorithms for simulating service disciplines.
afraid - a frequently redundant array of independent disks. disk arrays are commonly designed to ensure that stored data will always be able to withstand a disk failure, but meeting this goal comes at a significant cost in performance. we show that this is unnecessary. by trading away a fraction of the enormous reliability provided by disk arrays, it is possible to achieve performance that is almost as good as a non-parity-protected set of disks. in particular, our afraid design eliminates the small-update penalty that plagues traditional raid 5 disk arrays. it does this by applying the data update immediately, but delaying the parity update to the next quiet period between bursts of client activity. that is, afraid makes sure that the array is frequently redundant, even if it isn't always so. by regulating the parity update policy, afraid allows a smooth trade-off between performance and availability. under real-life workloads, the afraid design can provide close to the full performance of an array of unprotected disks, and data availability comparable to a traditional raid 5. our results show that afraid offers 42% better performance for only 10% less availability, 97% better for 23% less, and as much as a factor of 4.1 times better performance for giving up less than half raid 5's availability. we explore here the detailed availability and performance implications of the afraid approach.
transparent fault tolerance for parallel applications on networks of workstations. this paper describes a new method for providing transparent fault tolerance for parallel applications on a network of workstations. we have designed our method in the context of shared object system called sam, a portable run-time system which provides a global name space and automatic caching of shared data. sam incorporates a novel design intended to address the problem of the high communication overheads in distributed memory environments and is implemented on a variety of distributed memory platforms. our fundamental approach to providing fault tolerance is to ensure the replication of all data on more than one workstation using the dynamic caching already providedby sam. the replicated data is accessible to the local processor like other cached data, making access to shared data faster and potentially offsetting some of the fault tolerance overhead. in addition, our method uses information available in sam applications on how processes access shared data to enable several optimizations which reduce the fault-tolerance overhead. we have built an implementation of our fault-tolerance method in sam for heterogeneous networks of workstations running pvm3. in this paper, we present our fault-tolerance method and describe its implementation in detail. we give performance results and overhead numbers for several large sam applications running on a cluster of alpha workstations connected by an atm network. our method is successful in providing transparent fault tolerance for parallel applications running on a network of workstations and is unique in requiring no global synchronizations and no disk operations to a reliable file server.
lap: a little language for os emulation. lap, the linux application platform, is a linux emulation package for bsd/os which uses a "little language" [salu98] to describe transformations from linux data types and values to bsd/os data types and values, and vice versa. the little language simplifies and regularizes the specification of transformations, making the emulation easier to maintain. this paper describes the language and its place in the framework of lap.
an implementation of a log-structured file system for unix. research results [rose91] suggest that a log-structured file system (lfs) offers the potential for dramatically improved write performance, faster recovery time, and faster file creation and deletion than traditional unix file systems. this paper presents a redesign and implementation of the sprite [rose91] log-structured file system that is more robust and integrated into the vnode interface [klei86]. measurements show its performance to be superior to the 4bsd fast file system (ffs) in a variety of benchmarks and not significantly less than ffs in any test. unfortunately, an enhanced version of ffs (with read and write clustering) [mcvo91] provides comparable and sometimes superior performance to our lfs. however, lfs can be extended to provide additional functionality such as embedded transactions and versioning, not easily implemented in traditional file systems.
journaling versus soft updates: asynchronous meta-data protection in file systems. the unix fast file system (ffs) is probably the most widely-used file system for performance comparisons. however, such comparisons frequently overlook many of the performance enhancements that have been added over the past decade. in this paper, we explore the two most commonly used approaches for improving the performance of meta-data operations and recovery: journaling and soft updates. journaling systems use an auxiliary log to record meta-data operations and soft updates uses ordered writes to ensure metadata consistency. the commercial sector has moved en masse to journaling file systems, as evidenced by their presence on nearly every server platform available today: solaris, aix, digital unix, hp-ux, irix, and windows nt. on all but solaris, the default file system uses journaling. in the meantime, soft updates holds the promise of providing stronger reliability guarantees than journaling, with faster recovery and superior performance in certain boundary cases. in this paper, we explore the benefits of soft updates and journaling, comparing their behavior on both microbenchmarks and workload-based macrobenchmarks. we find that journaling alone is not sufficient to "solve" the meta-data update problem. if synchronous semantics are required (i.e., meta-data operations are durable once the system call returns), then the journaling systems cannot realize their full potential. only when this synchronicity requirement is relaxed can journaling systems approach the performance of systems like soft updates (which also relaxes this requirement). our asynchronous journaling and soft updates systems perform comparably in most cases. while soft updates excels in some meta-data intensive microbenchmarks, the macrobenchmark results are more ambiguous. in three cases soft updates and journaling are comparable. in a file intensive news workload, journaling prevails, and in a small isp workload, soft updates prevails.