ppxscal/embedding_network huggingface dataset:
Rotating combined queueing (RCQ): bandwidth and latency guarantees in low-cost, high-performance networks
Authors: Jae H. Kim, Andrew A. Chien
Venue: Proceedings of the 23rd annual international symposium on Computer architecture (1996)

Network service guarantees not only provide significant performance benefits to distributed computing systems (more balanced resource utilization, fast fault recovery, and fair network access), but they are also essential for many new applications requiring real-time communications with continuous data types (audio/video). Most existing algorithms which provide network service guarantees are too complicated to be feasible in high-speed, low-cost switches for multicomputer networks. The simpler algorithms proposed provide only limited service guarantees or waste significant network resources.We present a novel, cost-effective queueing and scheduling algorithm, called Rotating Combined Queueing (RCQ), which can efficient]y support a range of service guarantees including deterministic delay bounds and bandwidth guarantees in multicomputer networks. By allowing bursty traffic to utilize unused network resources efficiently, RCQ also can provide competitive performance to best-effort data communications. Such cost-effective service guarantees not only provide substantial benefits to the overall system performance, but can also further expand the domain of multicomputer applications to encompass distributed multimedia applications requiring isochronous communications.
Dynamic Prioritized Conflict Resolution on Multiple Access Broadcast Networks
Authors: Charles U. Martel, W. Melody Moh, Teng-Sheng Moh
Venue: IEEE Transactions on Computers (1996)

In a multiple access broadcast network, all network nodes share a single shared communication channel, and there is the possibility of a collision when two or more nodes transmit at overlapping times. We propose a dynamic prioritized conflict resolution algorithm in which, when a collision occurs, all colliding messages are retransmitted according to their priority. When a new message arrives, it is allowed to participate in the algorithm as soon as it finds its priority is higher than that of some broadcast message. Using a time-slotted model, for any arrival pattern and priority distribution, we show that our algorithm runs in expected linear time, i.e., O(r), where r is the total number of message transmitted. We also show that the expected waiting time for any message x is O((rank(x) + log s), where rank(x) is the expected number of messages with higher priority which transmit while x is waiting, and s is the minimum of the total number of messages participating in the algorithm and the total number of nodes in the network. The analysis presented in this work also includes an improved analysis of our original (static) prioritized conflict resolution algorithm. This work is applicable to multimedia communications where different priority values could be assigned to different kinds of traffic, and our algorithm ensures that the high-priority real-time traffic has the minimum delay.
Reduced instruction set computers
Authors: David A. Patterson
Venue: Communications of the ACM (1985)

Reduced instruction set computers aim for both simplicity in hardware and synergy between architectures and compilers. Optimizing compilers are used to compile programming languages down to instructions that are as unencumbered as microinstructions in a large virtual address space, and to make the instruction cycle time as fast as possible.
The use of memory in text processing
Authors: Michael Lebowitz
Venue: Communications of the ACM (1988)

The performance of a natural language processing system should improve as it reads more and more texts. This is true both for systems intended as cognitive models and for practical text processing systems. Permanent long-term memory should be useful during all stages of text understanding. For example, if, while reading a patent abstract about a new disk drive, a system can retrieve information about similar objects from memory, processing should be simplified. However, most natural language programs do not exhibit such learning behavior. We describe in this article how RESEARCHER, a program that reads, remembers and generalizes from patent abstracts, makes use of its automatically generated memory to assist in low-level text processing, primarily involving disambiguation that could be accomplished no other way. We describe both RESEARCHER's basic understanding methods and the integration of memory access. Included is an extended example of RESEARCHER processing a patent abstract by using information about several other abstracts already in memory.
Temporal difference learning and TD-Gammon
Authors: Gerald Tesauro
Venue: Communications of the ACM (1995)

Ever since the days of Shannon's proposal for a chess-playing algorithm [12] and Samuel's checkers-learning program [10] the domain of complex board games such as Go, chess, checkers, Othello, and backgammon has been widely regarded as an ideal testing ground for exploring a variety of concepts and approaches in artificial intelligence and machine learning. Such board games offer the challenge of tremendous complexity and sophistication required to play at expert level. At the same time, the problem inputs and performance measures are clear-cut and well defined, and the game environment is readily automated in that it is easy to simulate the board, the rules of legal play, and the rules regarding when the game is over and determining the outcome.
On the scalability problem in COTS-based programming environments
Authors: John Favaro
Venue: ACM SIGSOFT Software Engineering Notes (1996)

This article reports on a software design experience in which the concept of scalability is applied to the architecture of a software development environment based upon Commercial-Off-The-Shelf (COTS) tools. The experience has raised many issues, which are summarized here together with attempts to analyse their origins and indicate solutions. We believe that problems with the introduction of scalability will be encountered by any project attempting the integration of heterogeneous COTS products.
CAT&mdash;caching address tags: a technique for reducing area cost of on-chip caches
Authors: Hong Wang, Tong Sun, Qing Yang
Venue: Proceedings of the 22nd annual international symposium on Computer architecture (1995)

This paper presents a technique for minimizing chip-area cost of implementing an on-chip cache memory of microprocessors. The main idea of the technique Caching Address Tags, or CAT cache for short. The CAT cache exploits locality property that exists among addresses of memory references for the purpose of minimizing chip area-cost of address tags. By keeping only a limited number of distinct tags of cached data rather than having as many tags as cache lines, the CAT cache can reduce the cost of implementing tag memory by an order of magnitude without noticeable performance difference from ordinary caches. Therefore, CAT represents another level of caching for cache memories. Simulation experiments are carried out to evaluate performance of CAT cache as compared to existing caches. Performance results of SPEC92 programs show that the CAT cache with only a few tag entries performs as well as ordinary caches while chip-area saving is significant. Such area saving will increase as the address space of a processor increases. By allocating the saved chip area for larger cache capacity, or more powerful functional units, CAT is expected to have a great impact on overall system performance.
Conditions for Robustness and Nonrobustness of theStability of Feedback Systems with Respect to Small Delays inthe Feedback Loop
Authors: Hartmut Logemann, Richard Rebarber, George Weiss
Venue: SIAM Journal on Control and Optimization (1996)

It has been observed that for many stable feedback control systems, the introduction of arbitrarily small time delays into the loop causes instability. In this paper we present a systematic frequency domain treatment of this phenomenon for distributed parameter systems. We consider the class of all matrix-valued transfer functions which are bounded on some right half-plane and which have a limit at $+\spinfty$ along the real axis. Such transfer functions are called regular. Under the assumption that a regular transfer function is stabilized by unity output feedback, we give sufficient conditions for the robustness and for the nonrobustness of the stability with respect to small time delays in the loop. These conditions are given in terms of the high-frequency behavior of the open-loop system. Moreover, we discuss robustness of stability with respect to small delays for feedback systems with dynamic compensators. In particular, we show that if a plant with infinitely many poles in the closed right half-plane is stabilized by a controller, then the stability is not robust with respect to delays. We show that the instability created by small delays is itself robust to small delays. Three examples are given to illustrate these results.
How to make a recoverable server by synchronization code inheriting
Authors: A. Romanovsky
Venue: ACM SIGPLAN OOPS Messenger (1995)

We consider the practical problem of facilitating the re-design of the servers implemented in concurrent OO languages in such a way that these new servers will be recoverable. On the one hand, any ad hoc approaches to this re-design can be quite error prone. On the other hand, it would be important to reuse the most part of the initial servers' code. That is why we are trying to find quite a routine way to change a server behaviour by inheriting from its initial super class. We use the last achievements in the field of inheriting synchronization code to solve this problem. It is not a paper about new features for COOLs but this is a paper about how new features of COOLs can be used in one specific field: fault tolerance of concurrent systems.
Algorithm 754: Fortran subroutines for approximate solution of dense quadratic assignment problems using GRASP
Authors: Mauricio G. C. Resende, Panos M. Pardalos, Yong Li
Venue: ACM Transactions on Mathematical Software (TOMS) (1996)

In the NP-complete quadratic assignment problem (QAP), n facilities are to be assigned to n sites at minimum cost. The contribution of assigning facility i to site k and facility j to site l to the total cost is fij dkl, where fij is the flow between facilities i and j, and dkl is the distance between sites k and l. Only very small (n&le;20) instances of the QAP have been solved exactly, and heuristics are therefore used to produce approximate solutions. This article describes a set of Fortran subroutines to find approximate solutions to dense quadratic assignment problems, having at least one symmetric flow or distance matrix. A greedy, randomized, adaptive search procedure (GRASP) is used to produce the solutions. The design and implementation of the code are described in detail, and extensive computational experiments are reported, illustrating solution quality as a function of running time.
Proper packaging promotes parameter passing proficiency
Authors: John F. Čigas
Venue: ACM SIGPLAN Notices (1995)

There are three major areas of confusion when learning about parameter passing in procedural programming language: formal vs. actual parameters; scope rules, including global variables; and value vs. reference parameters. This paper discusses one simple method, the use of separate modules/packages, to ameliorate the first two of these problems.
L-systems with inheritance: an object-oriented extension of L-systems
Authors: Igor A. Borovikov
Venue: ACM SIGPLAN Notices (1995)

L-objects are introduced as L-systems with some object-oriented extensions. Inheritance is the principal new feature of L-objects. We discuss both the abstract basis and the program implementation of the new L-systems technique. The L-objects programming language defined here brings new qualities to L-systems design: modularity, code reusability, polymorphism and data abstraction.
An approach to support automatic generation of user interfaces
Authors: Prasun Dewan, Marvin Solomon
Venue: ACM Transactions on Programming Languages and Systems (TOPLAS) (1990)

In traditional interactive programming environments, each application individually manages its interaction with the human user. The result is duplication of effort in implementing user interface code and nonuniform&mdash;hence confusing&mdash;input conventions. This paper presents an approach to support automatic generation of user interfaces in environments based on algebraic languages. The approach supports the editing model of interaction, which allows a user to view all applications as data that can be edited. An application interacts with a user by submitting variables (of arbitrary types) to a dialogue manager, which displays their presentations to the user and offers type-directed editing of these presentations. Applications and dialogue managers communicate through a protocol that allows a presentation to be kept consistent with the variable it displays. A particular implementation of the approach, called Dost, has been constructed for the Xerox development environment and the Mesa programming language. Dost is used as a concrete example to describe the editing model, the primitives to support it, and our preliminary experience with these primitives. The approach is compared with related work, its shortcomings are discussed, and suggestions for future work are made.
MGS: a multigrain shared memory system
Authors: Donald Yeung, John Kubiatowicz, Anant Agarwal
Venue: ACM SIGARCH Computer Architecture News (1996)

Parallel workstations, each comprising 10-100 processors, promise cost-effective general-purpose multiprocessing. This paper explores the coupling of such small- to medium-scale shared memory multiprocessors through software over a local area network to synthesize larger shared memory systems. We call these systems Distributed Scalable Shared-memory Multiprocessors (DSSMPs).This paper introduces the design of a shared memory system that uses multiple granularities of sharing, and presents an implementation on the Alewife multiprocessor, called MGS. Multigrain shared memory enables the collaboration of hardware and software shared memory, and is effective at exploiting a form of locality called multigrain locality. The system provides efficient support for fine-grain cache-line sharing, and resorts to coarse-grain page-level sharing only when locality is violated. A framework for characterizing application performance on DSSMPs is also introduced.Using MGS, an in-depth study of several shared memory applications is conducted to understand the behavior of DSSMPs. We find that unmodified shared memory applications can exploit multigrain sharing. Keeping the number of processors fixed, applications execute up to 85% faster when each DSSMP node is a multiprocessor as opposed to a uniprocessor. We also show that tightly-coupled multiprocessors hold a significant performance advantage over DSSMPs on unmodified applications. However, a best-effort implementation of a kernel from one of the applications allows a DSSMP to almost match the performance of a tightly-coupled multiprocessor.
Program integration for languages with procedure calls
Authors: David Binkley, Susan Horwitz, Thomas Reps
Venue: ACM Transactions on Software Engineering and Methodology (TOSEM) (1995)

Given a program Base and two variants, A and B, each created by modifying separate copies of Base, the goal of program integration is to determine whether the modifications interfere, and if they do not, to create an integrated program that incorporates both sets of changes as well as the portions of Base preserved in both variants. Text-based integration techniques, such as the one used by the Unix diff3 utility, are obviously unsatisfactory because one has no guarantees about how the execution behavior of the integrated program relates to the behaviors of Base, A, and B. The first program integration algorithm to provide such guarantees was developed by Horwitz, Prins, and Reps. However, a limitation of that algorithm is that it only applied to programs written in a restricted language&mdash;in particular, the algorithm does not handle programs with procedures. This article describes a generalization of the Horwitz-Prins-Reps algorithm that handles programs that consist of multiple (and possibly mutually recursive) procedures.We show that two straightforward generalizations of the Horwitz-Prins-Reps algorithm yield unsatisfactory results. The key issue in developing a satisfactory algorithm is how to take into account different calling contexts when determining what has changed in the variants A and B. Our solution to this problem involves identifying two different kinds of affected components of A and B: those affected regardless of how the procedure is called, and those affected by a changed or new calling context. The algorithm makes use of interprocedural program slicing to identify these components, as well as components in Base, A, and B with the same behavior.
Going digital: a look at assumptions underlying digital libraries
Authors: David M. Levy, Catherine C. Marshall
Venue: Communications of the ACM (1995)

What are digital libraries, how should they be designed, how will they be used, and what relationship will they bear to what we now call &ldquo;libraries&rdquo;? Although we cannot hope to answer all these crucial questions in this short article, we do hope to encourage, and in some small measure to shape, the dialog among computer scientists, librarians, and other interested parties out of which answers may arise. Our contribution here is to make explicit, and to question, certain assumptions that underlie current digital library efforts. We will argue that current efforts are limited by a largely unexamined and unintended allegiance to an idealized view of what libraries have been, rather than what they actually are or could be. Since these limits come from current ways of thinking about the problem, rather than being inherent in the technology or in social practice, expanding our conception of digital libraries should serve to expand the scope and the utility of development efforts.
Dienst: an architecture for distributed document libraries
Authors: Carl Lagoze, James R. Davis
Venue: Communications of the ACM (1995)

As one of the five universities participating in the ARPA-sponsored Computer Science Technical Report project, we at Cornell have developed a digital library architecture called Dienst. Dienst is a protocol and implementation that provides Internet access to a distributed, decentralized multi-format document collection. The collection is managed by a set of interoperating Dienst servers distributed over the Internet. These servers provide three digital library services: repositories of multi-format documents; indexes into the document collection and search engines for these indexes; and user interfaces for browsing, searching, and accessing the collection.
Templar: a knowledge-based language for software specifications using temporal logic
Authors: Alexander Tuzhilin
Venue: ACM Transactions on Information Systems (TOIS) (1995)

A software specification language Templar is defined in this article. The development of the language was guided by the following objectives: requirements specifications written in Templar should have a clear syntax and formal semantics, should be easy for a systems analyst to develop and for an end-user to understand, and it should be easy to map them into a broad range of design specifications. Templar is based on temporal logic and on the Activity-Event-Condition-Activity model of a rule which is an extension of the Event-Condition-Activity model in active databases. The language supports a rich set of modeling primitives, including rules, procedures, temporal logic operators, events, activities, hierarchical decomposition of activities, parallelism, and decisions combined together into a cohesive system.
Fault-tolerance in air traffic control systems
Authors: Flaviu Cristian, Bob Dancey, Jon Dehn
Venue: ACM Transactions on Computer Systems (TOCS) (1996)

The distributed real-time system services developed by Lockheed Martin's Air Traffic Management group serve the infrastructure for a number of air traffic control systems. Either completed development or under development are the US Federal Aviation Administration's Display System Replacement (DSR) system, the UK Civil Aviation Authority's New Enroute Center (NERC) system, and the Republic of China's Air Traffic Control Automated System (ATCAS). These systems are intended to replace present en route systems over the next decade. High availability of air traffic control services is an essential requirement of these systems. This article discusses the general approach to fault-tolerance adopted in this infrastructure, by reviewing some of the questions which were asked during the system design, various alternative solutions considered, and the reasons for the design choices made. The aspects of this infrastructure chosen for the individual ATC systems mentioned above, along with the status of those systems, are presented in the Section 11 of the article.
Computer programming in high school vs. college
Authors: Martina Schollmeyer
Venue: Proceedings of the twenty-seventh SIGCSE technical symposium on Computer science education (1996)

Although there exists a computer science certification exam for high school teachers in some states, there appear to be no general requirements for teaching computer science at the high school level in most states. This may imply that CS material taught at the high school level is not always well-suited for students who want to pursue CS in college.This paper discusses some observations on what skills and abilities are important to prepare high school students for a successful career in CS at the college level. It also discusses preconceived ideas of college freshmen on what computer programming is all about.
Japan: computer graphics art and design education
Authors: Masa Inakage
Venue: ACM SIGGRAPH Computer Graphics (1996)

Japan has been one of the leading countries in both computer graphics production and research. In this report, we provide an overview of computer graphics education in Japan today, and conclude with types of job possibilities for Japanese students in the computer graphics industry.We begin with the Japanese education system in general. The Japanese education system is controlled by the Ministry of Education. Six years of elementary school and three years of junior high school are mandatory education, which allows all children to be equally educated. Three years of high school and above are considered as optional education. However, the majority of children will enter high school, and many will pursue higher education. The Ministry of Education has installed personal computers in most of the public elementary and junior high schools. However, in many cases, teachers lack computer literacy. It is very unusual to find computer graphics education taking place below the high school level, although there are some exceptions. The Japanese education system for higher education can be broken down into three categories: graduate level, four-year undergraduate level and two-year junior college level. In addition, there are specialized schools that offer certificates in specific areas.College exchange programs are not common in Japan. For example, art students in an art school are not able to take computer graphics courses offered at another university. It is also difficult for a student in one department to take courses in another department. The lack of cross-disciplinary education is a problem for computer graphics because the subject requires fundamental understanding in both art and design and computer science.