waashk/dblp huggingface dataset:
cse - a c++ servlet environment for high-performance web applications. current environments for web application development focus on java or scripting languages. developers that want to or have to use c or c++ are left behind with little options. we have developed a c/c++ servlet environment (cse) that provides a high performance servlet engine for c and c++. one of the biggest challenges we have faced while developing this environment was to come up with an architecture that provides high performance while not allowing a single servlet to crash the whole servlet environment, a serious risk with c and c++ application development. in this paper we explain our architecture, the challenges and trade-offs we have faced, and compare the performance of our environment to that of top servlet environments available today.
world wide web cache consistency. the bandwidth demands of the world wide web continue to grow at a hyper-exponential rate. given this rocketing growth, caching of web objects as a means to reduce network bandwidth consumption is likely to be a necessity in the very near future. unfortunately, many web caches do not satisfactorily maintain cache consistency. this paper presents a survey of contemporary cache consistency mechanisms in use on the internet today and examines recent research in web cache consistency. using trace-driven simulation, we show that a weak cache consistency protocol (the one used in the alex ftp cache) reduces network bandwidth consumption and server load more than either time-to-live fields or an invalidation protocol and can be tuned to return stale data less than 5% of the time.
a new object-oriented programming language: sh. many have frittered away their time on c++, while overlooking the new, posix.2-required, object-oriented language: sh. as will be clear from the enclosed code, the name may allude to the fact that the author would be embarrassed to have anyone find out about it. this paper introduces a tiny, object-oriented programming system written entirely in posix-conforming shell scripts.
workstation support for real-time multimedia communication. we show how multimedia applications with real-time requirements can be supported in a distributed system. a unix system has been modified to give soft real-time support. the modifications include deadline-based scheduling, preemption points and prioritized interrupt processing. in addition, a system call interface for real-time application programming has been designed. we justify the modifications by experiments with a simple distributed multimedia delivery system. the experiments are made on an atm network, where resources are reserved by means of the st-2 internetworking protocol.
call path profiling of monotonic program resources in unix. practical performance improvement of a complex program must be guided by empirical measurements of its resource usage. essentially, the programmer wants to know where in the source code the program is inefficient and why this is so. the process interface of unix system v (proc(4)) provides access to the raw data (e.g. time, faults, traps, and system calls) necessary to answering the why question, but gives no guidance in answering the where question. this paper describes a novel approach to the latter, call path profiling, which is both more informative and more closely tied to the process of program optimization than either trace-based or prof/gprof-like approaches. in addition, by viewing consumption of a resource as the ticking of a clock, we generalize the interval-based sampling approach of time profilers to arbitrary monotonic resources. the approach is embodied in several prototypes, including cpprof which operates under system v.
implementing internet key exchange (ike). a key component of the ip security architecture is the internet key exchange protocol. ike is invoked to establish session keys (and associated cryptographic and networking configuration) between two hosts across the network. ike needs to authenticate and authorize the parties involved in an exchange, negotiate parameters to be used for the communication, and interact with the local ipsec stack. the number of tasks, along with the flexibility built into the protocol, as well as the need to allow future additions and modifications to the protocol, need to be taken into consideration when designing and implementing ike. another complicating factor is the need for security policy management. although ike can establish security associations with remote hosts, some method for determining what kinds of traffic can and should be exchanged with a remote host is necessary. as there is no standard specification yet, we are using a trust-management based approach using the keynote system as a basis for specifying policy. this paper discusses the design, architecture, and implementation details of the openbsd ike daemon, with separate mention of the security policy mechanism.
modular construction of dte policies. this paper describes a tool which composes a policy for a fine-grained mandatory access control system (dte) from a set of mostly independent policy modules. for a large system with many services, a dte policy becomes unwieldy. however, many system services and security extensions can be considered to be largely standalone. by providing for explicit grouping, namespaces, and globbing by namespaces, inter-module access rules can be made generic enough to permit modules to be mixed and matched as needed. as a result, it becomes easier to extend a policy, debug a policy, and to distribute meaningful policy modules with new software.
the spring nucleus: a microkemel for objects. copyright 1993 usenix. reprinted with permission. the spring system is a distributed operating system that supports a distributed, object-oriented application framework. each individual spring system is based around a microkernel known as the nucleus, which is structured to support fast cross-address-space object invocations. this paper discusses the design rationale for the nucleus's ipc facilities and how they fit into the overall spring programming model. we then describe how the internal structure of the nucleus is organized to support fast cross-address-space calls, including some specific details and performance information on the current implementation.
location-aware scheduling with minimal infrastructure. mobile computers often benefit from software which adapts to their location. for example, a computer might be backed up when at the office, or the default printer might always be a nearby one. in many existing systems, location-triggered actions are only possible for specific applications or with special infrastructure. this paper describes lcron, a system which supports user-configurable actions triggered on change in location or other events common to mobile computers. key features of lcron are its use of existing clues for location information and mapping low-level location information into user-sensible terms. lcron uses a number of existing sources of location such as network connection and base station id, allowing it to work without special hardware or gps receivers. we map sources of low-level information such as ip address and latitude/longitude into user-meaningful logical locations. we describe the design, implementation and our experiences with this system.
calliope: a distributed, scalable multimedia server. calliope is a distributed multimedia server constructed from personal computers. preliminary performance measurements indicate that calliope can be scaled from a single pc producing about 22 mpeg-1 video streams to hundreds of pcs producing thousands of streams. the system can store both variable-and constant-rate video and audio encodings and can deliver them over any network supported by the underlying operating system. calliope is cost-effective because it requires only commodity hardware and portable because it runs under unix.
file system design for an nfs file server appliance. network appliance corporation recently began shipping a new kind of network server called an nfs file server appliance, which is a dedicated server whose sole function is to provide nfs file service. the file system requirements for an nfs appliance are different from those for a general-purpose unix system, both because an nfs appliance must be optimized for network file access and because an appliance must be easy to use. this paper describes wafl (write anywhere file layout), which is a file system designed specifically to work in an nfs appliance. the primary focus is on the algorithms and data structures that wafl uses to implement snapshotst, which are read-only clones of the active file system. wafl uses a copy-on-write technique to minimize the disk space that snapshots consume. this paper also describes how wafl uses snapshots to eliminate the need for file system consistency checking after an unclean shutdown.
optimizing the performance of dynamically-linked programs. dynamically-linked programs in general do not perform as well as statically-linked programs. this paper identifies three main areas that account for the performance loss. first, symbols are referenced indirectly and thus extra instructions are required. second, the overhead in run-time symbol resolution is significant. third, poor locality of functions in shared libraries and data structures maintained by the run-time linker may result in poor memory utilization. this paper presents new optimization techniques we developed that address these three areas and significantly improve the performance of dynamically-linked programs. also, we provide measurements of the performance improvement achieved. most importantly, we show that all desirable features of shared libraries can be achieved without sacrificing performance.
computer system performance problem detection using time series model. computer systems require monitoring to detect performance anomalies such as runaway processes, but problem detection and diagnosis is a complex task requiring skilled attention. although human attention was never ideal for this task, as networks of computers grow larger and their interactions more complex, it falls far short. existing computer-aided management systems require the administrator manually to specify fixed "trouble" thresholds. in this paper we report on an expert system that automatically sets thresholds, and detects and diagnoses performance problems on a network of unix computers. key to the success and scalability of this system are the time series models we developed to model the variations in workload on each host. analysis of the load average records of 50 machines yielded models which show, for workstations with simulated problem injection, false positive and negative rates of less than 1%. the server machines most difficult to model still gave average false positive/negative rates of only 6%/32%. observed values exceeding the expected range for a particular host cause the expert system to focus on that machine. there it applies tools with finer resolution and more discrimination, including per-command profiles gleaned from process accounting records. it makes one of 18 specific diagnoses and notifies the administrator, and optionally the user [a].
design and implementation of power-aware virtual memory. despite constant improvements in fabrication technology, hardware components are consuming more power than ever. with the ever-increasing demand for higher performance in highly-integrated systems, and as battery technology falls further behind, managing energy is becoming critically important to various embedded and mobile systems. in this paper, we propose and implement power-aware virtual memory to reduce the energy consumed by the memory in response to workloads becoming increasingly data-centric. we can use the power management features in current memory technology to put individual memory devices into low power modes dynamically under software control to reduce the power dissipation. however, it is imperative that any techniques employed weigh memory energy savings against any potential energy increases in other system components due to performance degradation of the memory. using a novel power-aware virtual memory implementation, we estimate a significant reduction in memory power dissipation, from 4.1 w to 0.5-2.7 w, based on rambus memory specifications, while running various real-world applications in a working linux system. unfortunately, due to a hardware bug in the chipset, direct power measurement is currently not possible. applying more advanced techniques, we can reduce power dissipation further to 0.2-1.7 w, depending on the actual workload, with negligible effects on performance. we also show this work is applicable to other memory architectures, and is orthogonal to previously-proposed hardware-controlled power-management techniques, so it can be applied simultaneously to further enhance energy conservation in a variety of platforms.
gecko: tracking a very large billing system. there is a growing need for very large databases which are not practical to implement with conventional relational database technology. these databases are characterised by huge size and frequent large updates; they do not require traditional database transactions, instead the atomicity of bulk updates can be guaranteed outside of the database. given the i/o and cpu resources available on modern computer systems, it is possible to build these huge databases using simple flat files and simply scanning all the data when doing queries. this paper describes gecko, a system for tracking the state of every call in a very large billing system, which uses sorted flat files to implement a database of about 60g records occupying 2.6tb. this paper describes gecko's architecture, both data and process, and how we handle interfacing with the existing legacy mvs systems. we focus on the performance issues, particularly with regard to job management, i/o management and data distribution, and on the tools we built. we finish with the important lessons we learned along the way, some tools we developed that would be useful in dealing with legacy systems, a benchmark comparing some alternative system architectures, and an assessment of the scalability of the system.
integrating handwriting recognition into unix. many new portable computers are substituting an electronic stylus, or pen, for the mouse. while the pen can serve as a simple replacement for the mouse, it also provides an enhanced drawing capability. this capability opens up the potential for new modes of user interaction, one of which is text input through handwriting instead of keyboard entry. in this paper, the integration of handwriting recognition into the unix operation system is discussed. we begin with an examination of the current state of the art in recognition algorithms and how handwriting recognition can enhance a user interface. a standard application program interface for handwriting recognition engines (hre api) is then presented. the hre api is distinguished from existing pc operating system api's in that it is specifically designed for multiple handwriting recognition engines of differing technologies, rather than a single, vendor-specific engine, and it shares a relatively narrow surface area with the window system. the latter characteristic allows it to be used with existing window systems, such as x, but does not hinder migration to other window systems should they become available. the api has been implemented with a public domain recognition engine and is currently being circulated among vendors of handwriting recognition engines for comment. finally, the paper concludes with a discussion of where handwriting recognition belongs in the current x window system architecture, and what would be needed to make handwriting an equal partner with typed keyboard input for text entry.
treadmarks: distributed shared memory on standard workstations and operating systems. treadmarks is a distributed shared memory (dsm) system for standard unix systems such as sunos and ultrix. this paper presents a performance evaluation of treadmarks running on ultrix using decstation-5000/240's that are connected by a 100-mbps switch-based atm lan and a 10-mbps ethernet. our objective is to determine the efficiency of a user-level dsm implementation on commercially available workstations and operating systems. we achieved good speedups on the 8-processor atm network for jacobi (7.4), tsp (7.2), quicksort (6.3), and ilink (5.7). for a slightly modified version of water from the splash benchmark suite, we achieved only moderate speedups (4.0) due to the high communication and synchronization rate. speedups decline on the 10-mbps ethernet (5.5 for jacobi, 6.5 for tsp, 4.2 for quicksort, 5.1 for ilink, and 2.1 for water), reflecting the bandwidth limitations of the ethernet. these results support the contention that, with suitable networking technology, dsm is a viable technique for parallel computation on clusters of workstations. to achieve these speedups, treadmarks goes to great lengths to reduce the amount of communication performed to maintain memory consistency. it uses a lazy implementation of release consistency, and it allows multiple concurrent writers to modify a page, reducing the impact of false sharing. great care was taken to minimize communication overhead. in particular, on the atm network, we used a standard low-level protocol, aal3/4, bypassing the tcp/ip protocol stack. unix communication overhead, however, remains the main obstacle in the way of better performance for programs like water. compared to the unix communication overhead, memory management cost (both kernel and user level) is small and wire time is negligible. this research was supported in part by the national science foundation under grants ccr-9116343, ccr-9211004, cda-9222911, and cda-9310073, by the texas advanced technology program under grant 003604014, and by a nasa graduate fellowship.
transparent network security policy enforcement. recent work in the area of network security, such as ipsec, provides mechanisms for securing the traffic between any two interconnected hosts. however, it is not always possible, economical, or even practical from an administration and operational point of view to upgrade the software and configuration of all the nodes in a network to support such security protocols. one apparent solution to this problem is the use of security gateways that apply the relevant security protocols on behalf of the protected nodes, under the assumption that the "last hop" between the security gateway and the end node is safe without cryptography. such a gateway can be set to enforce specific security policies for different types of traffic. while this solution is appealing in static scenarios (such as building so-called "intranets"), the use of layer-3 (network) routers as security gateways presents some transparency and configuration problems with regards to peer authentication in the automated key management protocol. this paper describes the architecture and implementation of a layer-2 (link layer) bridge with extensions for offering layer-3 security services. we extend the openbsd ethernet bridge to perform simple ip packet filtering and ipsec processing for incoming and outgoing packets on behalf of a protected node, completely transparently to both the protected and the remote communication endpoint. the same mechanism may be used to construct "virtual local area networks," by establishing ipsec tunnels between openbsd bridges connected geographically separated lans. as our system operates in the link layer, there is no need for software or configuration changes in the protected nodes.
dynamic vnodes - design and implementation. dynamic vnodes make the unix kernel responsive to a varying demand for vnodes, without a need to rebuild the kernel. it also optimizes the usage of memory by deallocating excess vnodes. this paper describes the design and implementation of dynamic vnodes in dec osf/1 v3.0. the focus is on the vnode deallocation logic in a symmetric multi-processing environment. deallocation of vnodes differs from the familiar concept of dynamically allocated data structures in the following ways: the legacy name-cache design implicitly assumes that vnodes are never deallocated, and the vnode free-list needs to cache unused vnodes effectively.
solaris mc: a multi computer os. solaris mc is a prototype distributed operating system for multi-computers (i.e. clusters of nodes) that provides a single-system image: a cluster appears to the user and applications as a single computer running the solaris®, operating system. solaris mc is built as a set of extensions to the base solaris unix®, system and provides the same abi/api as solaris, running unmodified applications. the components of solaris mc are implemented in c++ through a corba-compliant object oriented system with all new services defined by the idl definition language. objects communicate through a runtime system that borrows from solaris doors and spring subcontracts. solaris mc is designed for high availability: if a node fails, the remaining nodes remain operational. solaris mc has a distributed caching file system with unix consistency semantics, based on the spring virtual memory and file system architecture. process operations are extended across the cluster, including remote process execution and a global /proc file system. the external networks is transparently accessible from any node in the cluster. the prototype is fairly complete--we regularly exercise the system by running multiple copies of an off-the-shelf commercial database system.
operating system support for virtual machines. a virtual-machine monitor (vmm) is a useful technique for adding functionality below existing operating system and application software. one class of vmms (called type ii vmms) builds on the abstractions provided by a host operating system. type ii vmms are elegant and convenient, but their performance is currently an order of magnitude slower than that achieved when running outside a virtual machine (a standalone system). in this paper, we examine the reasons for this large overhead for type ii vmms. we find that a few simple extensions to a host operating system can make it a much faster platform for running a vmm. taking advantage of these extensions reduces virtualization overhead for a type ii vmm to 14-35% overhead, even for workloads that exercise the virtual machine intensively.
a network file system over http: remote access and modification of files and . the goal of the present httpfs project is to enable access to remote files, directories, and other containers through an http pipe. httpfs system permits retrieval, creation and modification of these resources as if they were regular files and directories on a local filesystem. the remote host can be any unix or win9x/winnt box that is capable of running a perl cgi script and accessible either directly or via a web proxy or a gateway. httpfs runs entirely in user space. the current implementation fully supports reading as well as creating, writing, appending, and truncating of files on a remote http host. httpfs provides an isolation level for concurrent file access stronger than the one mandated by posix file system semantics, closer to that of afs. both a programmatic interface with familiar open(), read(), write(), close(), etc. calls, and an interactive interface, via the popular midnight commander file browser, are provided.