waashk/acm huggingface dataset:
security and log structured file systems a log structured file system (lfs) obtains its performance by refraining from seeking for blocks on the disk. instead, new data is written into new blocks which is placed at the end of the log. this incurs a security issue by leaving data on disk that was supposed to be overwritten.to us, this shows how difficult it is for users concerned with their privacy, not to be lead astray. it also emphasizes how wide the gap is between an encryption channel and a user. tage stabell-kulø
a client-side stub interpreter  we have built a research operating system in which all services are presented through interfaces described by an interface description language. the system consists of a micro-kernel that supports a small number of these interfaces, and a large number of interfaces that are implemented by user level code. a typical service implements one or more interfaces, but it is a client of many other interfaces that are implemented elsewhere in the system. we have an interface compiler that generates client-side and server-side stubs to deliver calls from clients to servers, providing location transparency if the client and server are in different address spaces. the code for client-side stubs was occupying a large amount of the text space of our clients, so a stub interpreter was written to replace the client-side stub methods. the result was that we traded 125k bytes of stub code for 13k bytes of stub descriptions and 4k bytes of stub interpreter. this paper describes the stub interpreter, the stub descriptions, and discusses some alternatives.  peter b. kessler
a strategy for managing content complexity in algorithm animation computer animation is an excellent medium for capturing the dynamic nature of data structure manipulations, and can be used to advantage in the teaching of algorithms and data structures. a major educational issue is the necessity of providing a means for the student to manage the complexity of the material. we have addressed this issue in a multimedia teaching tool called "algorithms in action" by allowing students to view an algorithm at varying levels of detail. starting with a high level pseudocode description of the algorithm, with accompanying high level animation and textual explanation, students can expand sections of the pseudocode to expose more detail. animation and explanation are controlled in a coordinated fashion, becoming correspondingly more detailed as the pseudocode is expanded. the tool also supports dofferem , pdes. corresponding to different stages in the learning process. student feedback suggests that the availability of multiple levels detail and the facility for the user to control the level of detail being viewed is an effective way to manage content complexity. linda stern harald søndergaard lee naish
retargeting an ada source level debugger to cics  several characteristics of cics make design of an ada source level debugger difficult. this paper describes these difficulties, and solutions used in retargeting adaview , (a full featured ada source level debugger, written in ada), so that it can debug ada application programs running under cics. special consideration is given to debugging pseudoconversational applications, the most common type of cics interactive application. adaview's main part, running under mvs, communicates with a small cics resident part via sna lu 6.2 appc protocol.  g. snyder d. dunkle k. beitz
synchronizing clipboards of multiple computers  this paper describes a new technique for transferring data between computers, the synchronized clipboard. multiple computers can share a synchronized clipboard for all clipboard operations, so that data copied to the clipboard from one computer, using the standard copy command, can be pasted directly on another computer using the standard paste command. synchronized clipboards are well-suited for a single user moving data among several computers in close proximity. we describe an implementation of synchronized clipboards that works across a wide range of existing systems, including 3com palmpilots, microsoft windows pcs, unix workstations, and other java-capable platforms. our implementation adds no noticeable overhead to local copy and paste operations.  robert c. miller brad a. myers
recent progress in the performance evaluation of fundamental allocation algorithms  our understanding of several allocation algorithms basic to operating systems and to data base systems has improved substantially as a result of a number of research efforts within the past one or two years. the results have stirred considerable excitement in both theorists and practitioners. this is not only because of the inroads made into long-standing problems, but also because of the surprising nature of the results; in particular, we refer to proofs that certain classical algorithms described as approximate are in fact optimal in a strong probabilistic sense.  the work discussed here will be classified according to the application areas, archival and dynamic storage allocation. in both cases we are concerned with the packing problems that arise in making efficient use of storage. equivalents of the archival problems also have importance in scheduling applications [4]; however, we shall focus exclusively on the storage allocation setting.  e. g. coffman
power optimization using divide-and-conquer techniques for minimization of the number of operations  we introduce an approach for power optimization using a set of compilation and architectural techniques. the key technical innovation is a novel divide-and- conquer compilation technique to minimize the number of operations for general computations. our technique optimizes not only a significantly wider set of computations than the previously published techniques, but also outperforms (or performs at least as well as other techniques) on all examples. along the architectural dimension, we investigate coordinated impact of compilation techniques on the number of processors which provide optimal trade-off between cost and power. we demonstrate that proper compilation techniques can significantly reduce power with bounded hardware cost. the effectiveness of all techniques and algorithms is documented on numerous real-life designs.  inki hong miodrag potkonjak ramesh karri
a high-level abstraction of shared accesses  we describe the design and use of the tape mechanism, a new high-level abstraction of accesses to shared data for software dsms. tapes consolidate and generalize a number of recent protocol optimizations, including update- based locks and recorded-replay barriers. tapes are usually created by "recording" shared accesses. the resulting recordings can be used to anticipate future accesses by tailoring data movement to application semantics. tapes-based mechanisms are layered on top of existing shared-memory protocols, and are largely independent of the underlying memory model. tapes can also be used to emulate the data-movement semantics of several update- based protocol implementations, without altering the underlying protocol implementation. we have used tapes to create the tapeworm synchronization library. tapeworm implements sophisticated record-replay mechanisms across barriers, augments locks with data-movement semantics, and allows the use of producer-consumer segments, which move entire modified segments when any portion of the segment is accessed. we show that tapeworm eliminates 85% of remote misses, reduces message traffic by 63%, and improves performance by an average of 29% for our application suite.  peter j. keleher
optimizing multi-method dispatch using compressed dispatch tables  optimizing method dispatch is a central issue in object-oriented language implementation. the dispatch table scheme, used for example by c++, is the only implementation of method dispatch that offers constant time performance. this property is the main asset of dispatch tables and a major requirement for some languages. however, the major drawback of dispatch tables is the space they require. reducing the size of dispatch tables has been studied in the case of mono-methods with techniques such as coloring. in the case of multi- methods, dispatch tables are practically unusable as they grow as a power of the number of arguments. in this paper, we propose an algorithm to compress the dispatch tables of multi-methods by analyzing their signatures.  eric amiel olivier gruber eric simon
an overview of the "1981 acm sigmetrics workshop/symposium on measurement and evaluation of software quality"  the 1981 acm sigmetrics workshop/symposium on measurement and evaluation of software quality focused on the broad subject of software quality. it addressed some of the major topics covered by the term "software quality," including the software life cycle, software quality requirements, software configuration management, software quality assurance metrics, and software reliability measurement. over 220 practitioners and researchers from industry, government, and universities gathered together at the university of maryland conference center in college park on march 25-27 to participate in two tutorials and eight workship sessions. workship participants represented a wide range of interests from the purely qualitative to the purely quantitative.  john e. gaffney mitchell g. spiegel
coordinating distributed applets with shade as coordinated activities like electronic commerce and workflow systems are emerging as an important applications field of the internet, it is necessary to invent and test new programming languages suitable to design these applications. shade is a language for coordinating active pages including java applets. shade is based on a concept called the object space, that is used both as repository for objects and as coordination medium. the object space offers several services which can be exploited by java objects. we describe the basic ideas in the language, its current implementation and programming environment, and two applications in the fields of electronic commerce and workflow applications. p. ciancarini d. rossi
peoplegarden: creating data portraits for users  many on-line interaction environments have a large number of users. it is difficult for the participants, especially new ones, to form a clear mental image about those with whom they are interacting. how can we compactly convey information about these participants to each other? we propose the data portrait, a novel graphical representation of users based on their past interactions. data portraits can inform users about each other and the overall social environment. we use a flower metaphor for creating individual data portraits, and a garden metaphor for combining these portraits to represent an on-line environment. we will review previous work in visualizing both individuals and groups. we will then describe our visualizations, explain how to create them, and show how they can be used to address user questions.  rebecca xiong judith donath
a real-time monitor for a distributed real-time operating system  monitoring and debugging for a distributed real-time system is a complicated problem due to the lack of a set of advanced tools and adequate operating system capability. software tools can cover the wide range of the software development life cycle from the requirement analysis phase to debugging and maintenance phases. however, many of these modern tools are not effective for building or analyzing complex real-time systems. real-time software tools and effective kernel support are essential to reduce the complexity of real-time software. in this paper, we first address the issues in real-time monitoring and debugging, such as capturing the timing error, the monitor's invasive nature and visualization of system behavior. we then describe the architecture of the art real-time monitor which is being built for a distributed real-time os, called arts. the built-in monitoring/debugging kernel primitives are also mentioned.  hideyuki tokuda makoto kotera clifford e. mercer
what's new for scanning with ada-95? this paper illustrates how some new ada-95 features improve the versatility of scanning techniques. it will recall the definition of a scan, how scanning can be implemented in ada-83, and what problems are associated with scans, notably in passing them as (generic) parameters. after that, we will discuss accesses to subprograms and show that they cannot become a worthwhile solution, and finally show an unexpected solution with tagged types used as a factorisation of properties rather than as an implementation of inheritance mechanisms.from some low-level point of view, both generic and file-like scannings can look like theoretical fashions that have no interest. the real question beyond such scannings is whether we accept the application of these programming principles that have emerged from decades of programming professional practice, such as weak coupling, abstraction and encapsulation. we argue that it is essential to study in depth all the consequences of these programming principles before assessing their interest in real life. we conjecture that encapsulated scans could be of enough interest to be much more widely used in industrial projects.aside from industrial usages, scanning is a valid illustration of both tagged types and genericity, and we provided some suggested exercises for lecturers who would emphasize factorization of type properties and nested genericity or package parameters. michel gauthier
from flop to megaflops: java for technical computing  although there has been some experimentation with java as a language for numerically intensive computing, there is a perception by many that the language is unsuited for such work because of performance deficiencies. in this article we show how optimizing array bounds checks and null pointer checks creates loop nests on which aggressive optimizations can be used. applying these optimizations by hand to a simple matrix-multiply test case leads to java- compliant programs whose performance is in excess of 500 mflops on a four- processor 332mhz rs/6000 model f50 computer. we also report in this article the effect that various optimizations have on the performance of six floating- point-intensive benchmarks. through these optimizations we have been able to achieve with java at least 80% of the peak fortran performance on the same benchmarks. since all of these optimizations can be automated, we conclude that java will soon be a serious contender for numerically intensive computing.  jose e. moreira samuel p. midkiff manish gupta
the user command processor the user command processor is a new feature of several apl*plus systems which allows users to define commands, analogous to system commands, that can be executed from within any workspace. this enhancement is implemented by means of two simple changes to the apl interpreter. coupled with a suite of two-dozen predefined commands, the result is a file-based program storage and execution environment that integrates many important features not provided in standard apl systems. using the command processor, applications of unlimited size can be developed, run, and maintained without many of the headaches that are characteristic of workspace- based systems. this paper describes the basic methods whereby the command processor operates, provides an overview of the predefined commands, shows how a new command can be defined, and illustrates how a large application can be built using the command processor. jim weigang
memory utilization efficiency under a class of first-fit algorithms  this paper examines an improved version of a modified first-fit storage allocation algorithm. in this version, small blocks of free storage are not permitted to remain on the free list but instead are placed on a separate sliver list, available for recombination with newly freed blocks. the memory utilization efficiency of a system under this algorithm is shown to be markedly superior to a system using an algorithm in which such blocks are unavailable for either allocation or recombination.  aaron tenenbaum
programming considerations for documentation and maintenance  the intent of this paper is to create, or reinforce among programmers an awareness of some simple measures which can be taken during application system development, which can save valuable time later, when somebody else is called upon to document, fix, enhance, or otherwise read and work with their programs.  although the paper describes several approaches to system documentation, it is not expected that any programmer will henceforth develop his applications exclusively around and according to the needs of the technical writer or maintenance analyst. the hope is that by describing a broad range of techniques, individual programmers can select those which best suit their style and approach, while minimizing the imposition of rigid and burdensome "standards". the premise being that some, any, assistance provided to future readers, is better than none.  stephen c. fleming
asis-based code analysis automation the ada semantic interface specification (asis) is an interface between an ada environment and any tool requiring information from it. an ada environment comprises valuable semantic and syntactic information that can be exploited for automated code analysis. asis provides an open and published callable interface that gives access to this information; further, asis has been designed to be independent of underlying ada environment implementations, thus supporting portability of code analysis tools while relieving tool developers from needing to understand the complexities of an ada environment's proprietary and evolving internal representation. c. daniel cooper
an analysis of fortran utilization this paper presents the results of a survey of fortran users. the users were asked to identify the dialects of fortran used, other languages used, target architectures, feature utilization (data- parallel, object-orientation and abstract data typing), views on formalism in programming, and views on standard fortran and the standardization process. the results showed that the feature requirements of sequential and parallel users are divergent, but that in general fortran programmers are assimilating all that technology has to offer. n. reid j.p wray
abcd: eliminating array bounds checks on demand  to guarantee typesafe execution, java and other strongly typed languages require bounds checking of array accesses. because array-bounds checks may raise exceptions, they block code motion of instructions with side effects, thus preventing many useful code optimizations, such as partial redundancy elimination or instruction scheduling of memory operations. furthermore, because it is not expressible at bytecode level, the elimination of bounds checks can only be performed at run time, after the bytecode program is loaded. using existing powerful bounds-check optimizers at run time is not feasible, however, because they are too heavyweight for the dynamic compilation setting.  abcd is a light-weight algorithm for elimination of array bounds checks on demand. its design emphasizes simplicity and efficiency. in essence, abcd works by adding a few edges to the ssa value graph and performing a simple traversal of the graph. despite its simplicity, abcd is surprisingly powerful. on our benchmarks, abcd removes on average 45% of dynamic bound check instructions, sometimes achieving near-ideal optimization.  the efficiency of abcd stems from two factors. first, abcd works ona sparse representation. as a result, it requires on average fewer than 10 simple analysis steps per bounds check. second, abcd is demand- driven. it can be applied to a set of frequently executed (hot) bounds checks, which makes it suitable for the dynamic-compilation setting, in which compile-time cost is constrained but hot statements are known.  rastislav bodík rajiv gupta vivek sarkar
an empirical study of a model for program error prediction  accuracy in program error prediction is a major problem in quality control of a large- scale software system. this paper presents a model to estimate the number of errors remaining in a program at the beginning of the testing phase of development. ten hypothesized environmental factors are statistically analyzed and the model is then derived by using the factors significantly identified in the analysis. this empirical study was done with data collected during the development of large-scale software systems. results of the study indicate that factors such as frequency of program specification change, programmer's skill, and volume of program design document are significant and that the model based on these factors is more reliable than conventional error prediction methods based on program size alone.  muneo takahashi yuji kamayachi
analyzing exception flow in java programs  exception handling mechanisms provided by programming languages are intended to ease the difficulty of developing robust software systems. using these mechanisms, a software developer can describe the exceptional conditions a module might raise, and the response of the module to exceptional conditions that may occur as it is executing. creating a robust system from such a localized view requires a developer to reason about the flow of exceptions across modules. the use of unchecked exceptions, and in object-oriented languages, subsumption, makes it difficult for a software developer to perform this reasoning manually. in this paper, we describe a tool called jex that analyzes the flow of exceptions in java code to produce views of the exception structure. we demonstrate how jex can help a developer identify program points where exceptions are caught accidentally, where there is an opportunity to add finer-grained recovery code, and where error-handling policies are not being followed.  martin p. robillard gail c. murphy
avoidance and suppression of compensation code in a trace scheduling compiler  trace scheduling is an optimization technique that selects a sequence of basic blocks as a trace and schedules the operations from the trace together. if an operation is moved across basic block boundaries, one or more compensation copies may be required in the off-trace code. this article discusses the generation of compensation code in a trace scheduling compiler and presents techniques for limiting the amount of compensation code: avoidance (restricting code motion so that no compensation code is required) and suppression (analyzing the global flow of the program to detect when a copy is redundant). we evaluate the effectiveness of these techniques based on measurements for the spec89 suite and the livermore fortran kernels, using our implementation of trace scheduling for a multiflow trace 7/300. the article compares different compiler models contrasting the performance of trace scheduling with the performance obtained from typical risc compilation techniques.  there are two key results of this study. first, the amount of compensation code generated is not large. for the spec89 suite, the average code size increase due to trace scheduling is 6%. avoidance is more important than suppression, although there are some kernels that benefit significantly from compensation code suppression. since compensation code is not a major issue, a compiler can be more aggressive in code motion and loop unrolling. second, compensation code is not critical to obtain the benefits of trace scheduling. our implementation of trace scheduling improves the spec mark rating by 30% over basic block scheduling, but restricting trace scheduling so that no compensation code is required improves the rating by 25%. this indicates that most basic block scheduling techniques can be extended to trace scheduling without requiring any complicated compensation code bookkeeping.  stefan m. freudenberger thomas r. gross p. geoffrey lowney