waashk/acm huggingface dataset:
group consistency model which separates the intra-group consistency maintenance from the inter-group consistency maintenance in large scale dsm systems according to the characteristics of large scale network computing systems, we proposed a group consistency model based on the concept of group to construct a dsm system. the novel model can use different inter-group and intra-group consistencies and lend itself to flexible, easily-managable, and application-suitable dsm in large scale systems. a group consistency model, which applies entry consistency among groups and lazy release consistency in a group, together with its implementation policy is discussed in this paper. it employs write-update and multiple-writer protocols in a group, and thus facilitates the simultaneous read and write in a group. the suitable protocols eliminate the false sharing and reduce the data acquiring time in a group. furthermore, the inter-group consistency also suits the features of data sharing among groups and transmits the data modifications originated from a group in bulk to reduce the network traffic. in the end, an example using group consistency model is given and the trivial group consistency is discussed. qun li hua ji li xie
process migration in demos/mp  process migration has been added to the demos/mp operating system. a process can be moved during its execution, and continue on another processor, with continuous access to all its resources. messages are correctly delivered to the process's new location, and message paths are quickly updated to take advantage of the process's new location. no centralized algorithms are necessary to move a process.  a number of characteristics of demos/mp allowed process migration to be implemented efficiently and with no changes to system services. among these characteristics are the uniform and location independent communication interface, and the fact that the kernel can participate in message send and receive operations in the same manner as a normal process.  michael l. powell barton p. miller
the astoot approach to testing object-oriented programs  this article describes a new approach to the unit testing of object-oriented programs, a set of tools based on this approach, and two case studies. in this approach, each test case consists of a tuple of sequences of messages, along with tags indicating whether these sequences should put objects of the class under test into equivalent states and/or return objects that are in equivalent states. tests are executed by sending the sequences to objects of the class under test, then invoking a user-supplied equivalence-checking mechanism. this approach allows for substantial automation of many aspects of testing, including test case generation, test driver generation, test execution, and test checking. experimental prototypes of tools for test generation and test execution are described. the test generation tool requires the availability of an algebraic specification of the abstract data type being tested, but the test execution tool can be used when no formal specification is available. using the test execution tools, case studies involving execution of tens of thousands of test cases, with various sequence lengths, parameters, and combinations of operations were performed. the relationships among likelihood of detecting an error and sequence length, range of parameters, and relative frequency of various operations were investigated for priority queue and sorted-list implementations having subtle errors. in each case, long sequences tended to be more likely to detect the error, provided that the range of parameters was sufficiently large and likelihood of detecting an error tended to increase up to a threshold value as the parameter range increased.  roong-ko doong phyllis g. frankl
distributed communications  communications among multiple ada programs is a must, either as an explicit link or as an invisible link hidden beneath a distributed ada veneer. unisys has defined two ada package specifications for inter-program communications, that are derived from the requirements developed at the third international workshop on real-time ada issues (rtaw3). unisys is implementing these packages on several embedded real-time testbeds, both as standalone capabilities for application developers and as the communication layer supporting a distributed ada system. these specifications are proposed as a basis for a secondary standard for inter-program communication for ada9x.  this paper describes how these specifications match the rtaw3 requirements and the motivation for their features. some details of the specifications are interspersed throughout the text, with a full specification contained in the appendix.  m. kamrad j. cross
a concurrent, generational garbage collector for a multithreaded implementation of ml  this paper presents the design and implementation of a "quasi real-time" garbage collector for concurrent caml light, an implementation of ml with threads. this two- generation system combines a fast, asynchronous copying collector on the young generation with a non-disruptive concurrent marking collector on the old generation. this design crucially relies on the ml compile-time distinction between mutable and immutable objects.  damien doligez xavier leroy
ufo: a personal global file system based on user-level extensions to the operating system  in this article we show how to extend a wide range of functionality of standard operation systems completely at the user level. our approach works by intercepting selected system calls at the user level, using tracing facilities such as the /proc file system provided by many unix operating systems. the behavior of some intercepted system calls is then modified to implement new functionality. this approach does not require any relinking or recompilation of existing applications. in fact, the extensions can even be dynamically "installed" into already running processes. the extensions work completely at the user level and install without system administrator assistance. individual users can choose what extensions to run, in effect creating a personalized operating system view for themselves. we used this approach to implement a global file system, called ufo, which allows users to treat remote files exactly as if they were local. currently, ufo supports file access through the ftp and http protocols and allows new protocols to be plugged in. while several other projects have implemented global file system abstractions, they all require either changes to the operating system or modifications to standard libraries. the article gives a detailed performance analysis of our approach to extending the os and establishes that ufo introduces acceptable overhead for common applications even though intercepting individual system calls incurs a high cost.  albert d. alexandrov maximilian ibel klaus e. schauser chris j. scheiman
reliability growth modeling from fault failure rates a variety of reliability growth models provide quantified measures of test effectiveness in terms that are directly relevant to project management [lyu96], but at the cost of restricting testing to _representative_ selection, in which test data is chosen to reflect the operational distribution of the program's inputs. during testing, data is collected on the observed times between program failures (or, similarly, numbers of failures within a time interval). these observations are fitted to one of various models, which can then be used to estimate the current reliability of the program. steven j. zeil
incremental generation of lexical scanners  it is common practice to specify textual patterns by means of a set of regular expressions and to transform this set into a finite automaton to be used for the scanning of input strings. in many applications, the cost of this preprocessing phase can be amortized over many uses of the constructed automaton. in this paper new techniques for lazy and incremental scanner generation are presented. the lazy technique postpones the construction of parts of the automaton until they are really needed during the scanning of input. the incremental technique allows modifications to the original set of regular expressions to be made and reuses major parts of the previous automaton. this is interesting in applications such as environments for the interactive development of language definitions in which modifications to the definition of lexical syntax and the uses of the generated scanners alternate frequently.  j. heering p. klint j. rekers
structured analysis and object oriented analysis  the object-oriented paradigm still faces an open challenge: delivering huge software systems routinely and cost effectively. to quote ed yourdon: "a system composed of 100,000 lines of c++ is not be sneezed at, but we don't have that much trouble developing 100,000 lines of cobol today. the real test of oop will come when systems of 1 to 10 million lines of code are developed."  although the object-oriented community has an opening flirtation with exploratory programming and rapid prototyping by exploiting reuse via inheritance, there is for now, in my opinion, no hope that huge systems can be developed without giving due attention to what a target system is supposed to do. which should produce an (electronic) (graphical) (pseudo-formal) document, the requirements, that a customer can initially sign off. we believe as well that for huge systems a programming language independent design activity, that bridges the requirements and the actual programming effort, is mandatory. it goes without saying that we do not suggest that these activities constitute a waterfall sequence.  consequently, the object-oriented community needs to address the question whether well established analysis techniques, like structured analysis, jackson's jsd, etc. can be reused for object-oriented system development or whether a dedicated object-oriented analysis (and design) method is called for.  the panel members have been asked to consider the following of question: what is the relationship between structured analysis (sa) and object oriented analysis (ooa)?  more specifically:  can sa be used effectively to produce the requirements for a system that will be designed and implemented in an oo fashion?  if not, is it possible to adjust sa, what needs to be added? if sa cannot be used at all, what is the key obstacle?  in case sa and ooa have different applicability ranges, how do we circumscribe --- positively and negatively - these ranges? any overlap?  we appreciate that the organizing committee of this conference has selected this crucial topic.  dennis de champeaux larry constantine ivar jacobson stephen mellor paul ward edward yourdon
determinacy testing for nondeterminate logic programming languages  this paper describes an algorithm for the code generation of determinacy testing for nondeterminate flat concurrent logic programming languages. languages such as andorra and pandora require that procedure invocations suspend if there is more than one candidate clause potentially satisfying the goal. the algorithm described has been developed specifically for a variant of flat pandora based on fghc, although the concepts are general. we have extended kliger and shapiro's decision-graph construction algorithm to compile "don't-know" procedures that must suspend for nondeterminate goal invocation. the determinacy test is compiled into a decision graph quite different from those of committed-choice procedures: they are more similar to decision trees optimized by code sharing. we present both empirical data of compilation results (code size and graph characteristics), and a correctness proof for our code-generation algorithm.  e. tick m. korsloot
design and implementation of generics for the .net common language runtime  the microsoft.net common language runtime provides a shared type system, intermediate language and dynamic execution environment for the implementation and inter-operation of multiple source languages. in this paper we extend it with direct support for parametric polymorphism (also known as generics), describing the design through examples written in an extended version of the c# programming language, and explaining aspects of implementation by reference to a prototype extension to the runtime.  our design is very expressive, supporting parameterized types, polymorphic static, instance and virtual methods, "f-bounded" type parameters, instantiation at pointer and value types, polymorphic recursion, and exact run-time types. the implementation takes advantage of the dynamic nature of the runtime, performing just-in-time type specialization, representation-based code sharing and novel techniques for efficient creation and use of run-time types.  early performance results are encouraging and suggest that programmers will not need to pay an overhead for using generics, achieving performance almost matching hand-specialized code.  andrew kennedy don syme
higher-order concurrent programs with finite communication topology (extended abstract)  concurrent ml (cml) is an extension of the functional language standard ml(sml) with primitives for the dynamic creation of processes and channels and for the communication of values over channels. because of the powerful abstraction mechanisms the communication topology of a given program may be very complex and therefore an efficient implementation may be facilitated by knowledge of the topology.  this paper presents an analysis for determining when a bounded number of processes and channels will be generated. the analysis proceeds in two stages. first we extend a polymorphic type system for sml to deduce not only the type of cml programs but also their communication behaviour expressed as terms in a new process algebra. next we develop an analysis that given the communication behaviour predicts the number of processes and channels required during the execution of the cml program. the correctness of the analysis is proved using a subject reduction property for the type system.  hanne riis nielson flemming nielson
threads and input/output in the synthesis kernal  the synthesis operating system kernel combines several techniques to provide high performance, including kernel code synthesis, fine-grain scheduling, and optimistic synchronization. kernel code synthesis reduces the execution path for frequently used kernel calls. optimistic synchronization increases concurrency within the kernel. their combination results in significant performance improvement over traditional operating system implementations. using hardware and software emulating a sun 3/160 running sunos, synthesis achieves several times to several dozen times speedup for unix kernel calls and context switch times of 21 microseconds or faster.  h. massalin c. pu
the ravenscar tasking profile - experience reporting the ravenscar profile was defined at the 18th international real-time ada workshop as a simple subset of the tasking features of ada, in order to support efficient, high integrity applications that need to be analysed for their timing properties. ada compiler vendor aonix subsequently implemented the profile via its raven product line, and is currently engaged in producing the formal certification material for qualifying the runtime system to the most stringent set of guidelines --- do-178b level a. this paper describes some of the experiences in implementing and qualifying the profile, and some early indications from the user community of its value to address the application domains that it was intended for. brian dobbing george romanski
a distributed object-oriented framework for dependable multiparty interactions  in programming distributed object-oriented systems, there are several approaches for achieving binary interactions in a multiprocess environment. usually these approaches take care only of synchronisation or communication. in this paper we describe a way of designing and implementing a more general concept: multiparty interactions. in a multiparty interaction, several parties (objects or processes) somehow "come together" to produce an intermediate and temporary combined state, use this state to execute some activity, and then leave this interaction and continue their normal execution. the concept of multiparty interactions has been investigated by several researchers, but to the best of our knowledge none have considered how failures in one or more participants of the multiparty interaction can be dealt with. in this paper, we propose a general scheme for constructing dependable multiparty interactions in a distributed object-oriented system, and describe its implementation in java. in particular, we extend the notion of multiparty interaction to include facilities for handling exceptions. to show how our scheme can be used, we use our framework to build an abstraction mechanism that supports cooperative and competitive concurrency in distributed systems. this mechanism is then applied to program a system in which multiparty interactions are more than simple synchronisations or communications.  a. f. zorzo r. j. stroud
object-oriented programming with flavors  this paper describes symbolics' newly redesigned object-oriented programming system, flavors. flavors encourages program modularity, eases the development of large, complex programs, and provides high efficiency at run time. flavors is integrated into lisp and the symbolics program development environment. this paper describes the philosophy and some of the major characteristics of symbolics' flavors and shows how the above goals are addressed. full details of flavors are left to the programmers' manual, reference guide to symbolics common lisp. (5)  david a. moon
critical slicing for software fault localization developing effective debugging strategies to guarantee the reliability of software is important. by analyzing the debugging process used by experienced programmers, we have found that four distinct tasks are consistently performed: (1) determining statements involved in program failures, (2) selecting suspicious statements that might contain faults, (3) making hypotheses about suspicious faults (variables and locations), and (4) restoring program state to a specific statement for verification. this research focuses support for the second task, reducing the search domain for faults, which we refer to as _fault localization._we explored a new approach to enhancing the process of fault localization based on dynamic program slicing and mutation-based testing. in this new approach, we have developed the technique of critical slicing to enable debuggers to highlight suspicious statements and thus to confine the search domain to a small region. the critical slicing technique is partly based on "statement deletion" mutant operator of the mutation-based testing methodology. we have explored properties of critical slicing, such as the relationship among critical slicing, dynamic program slicing, and executable static program slicing; the cost to construct critical slices; and the effectiveness of critical slicing. results of experiments support our conjecture as to the effectiveness and feasibility of using critical slicing for fault localization.this paper explains our technique and summarizes some of our findings. from these, we conclude that a debugger equipped with our proposed fault localization method can reduce human interaction time significantly and aid in the debugging of complex software. richard a. demillo hsin pan eugene h. spafford
scheduling and page migration for multiprocessor compute servers  several cache-coherent shared-memory multiprocessors have been developed that are scalable and offer a very tight coupling between the processing resources. they are therefore quite attractive for use as compute servers for multiprogramming and parallel application workloads. process scheduling and memory management, however, remain challenging due to the distributed main memory found on such machines. this paper examines the effects of os scheduling and page migration policies on the performance of such compute servers. our experiments are done on the stanford dash, a distributed-memory cache-coherent multiprocessor. we show that for our multiprogramming workloads consisting of sequential jobs, the traditional unix scheduling policy does very poorly. in contrast, a policy incorporating cluster and cache affinity along with a simple page-migration algorithm offers up to two-fold performance improvement. for our workloads consisting of multiple parallel applications, we compare space-sharing policies that divide the processors among the applications to time-slicing policies such as standard unix or gang scheduling. we show that space-sharing policies can achieve better processor utilization due to the operating point effect, but time-slicing policies benefit strongly from user-level data distribution. our initial experience with automatic page migration suggests that policies based only on tlb miss information can be quite effective, and useful for addressing the data distribution problems of space-sharing schedulers.  rohit chandra scott devine ben verghese anoop gupta mendel rosenblum
reuse through inheritance: a quantitative study of c++ software  according to proponents of object-oriented programming, inheritance is an excellent way to organize abstraction and a superb tool for reuse. yet, few quantitative studies of the actual use of inheritance have been conducted. quantitative studies are necessary to evaluate the actual usefulness of structures such as inheritance. we characterize the use of inheritance in 19 existing c++ software systems containing 2,744 classes. we measure the class depth in the inheritance hierarchies, and the number of child and parent classes in the software. we find that inheritance is used far less frequently than expected.  james m. bieman josephine xia zhao
on the scale and performance of cooperative web proxy caching while algorithms for cooperative proxy caching have been widely studied, little is understood about cooperative-caching performance in the large-scale world wide web environment. this paper uses both trace-based analysis and analytic modelling to show the potential advantages and drawbacks of inter-proxy cooperation. with our traces, we evaluate quantitatively the performance-improvement potential of cooperation between 200 small-organization proxies within a university environment, and between two large-organization proxies handling 23,000 and 60,000 clients, respectively. with our model, we extend beyond these populations to project cooperative caching behavior in regions with millions of clients. overall, we demonstrate that cooperative caching has performance benefits only within limited population bounds. we also use our model to examine the implications of future trends in web-access behavior and traffic. alec wolman m. voelker nitin sharma neal cardwell anna karlin henry m. levy