bluuebunny/crossref_metadata_2025_split huggingface dataset:
The work of IFIP working group 6.1
Authors: Curran Alex , Cerf Vinton 
Published: October 2004

IFIP is a multinational federation of professional-technical societies concerned with information processing. At present, thirty-five national societies are members of the federation, united to achieve the following aims:
-to promote information science and technology;
-to advance information cooperation in the field of information processing;
-to stimulate research, development, and application of information processing in science and human activity;
-to further the dissemination and exchange of information about information processing; and
-to encourage education in information processing
Thus, IFIP is both a catalyst and a focal point for conceptual and technological developments which advance the state of the information processing art.
Within IFIP, the technical work is sponsored by a series of technical committees. Under their auspices, workshops, seminars, and conferences are organized to encourage research and technological progress, and to publish definitive texts on the state of that progress. At present, technical committees are working in such fields as:
-information processing terminology
-programming languages
-applications in education
-information processing in medicine
-applications in technology
-data communications
-modelling and optimization
-the effect of information processing on human institutions
In addition to the specialized events organized by the technical committees, IFIP sponsors a Congress once every three years which provides an overall view of the state of information processing science. The next Congress will be held in Toronto, Canada in August 1977.
The library of books published by IFIP now contains sixty volumes. They cover a variety of fields including applications in technology, administration and management, the description and use of programming languages, mathematical theory, computing education, applications in medicine and other human activities, terminology, and overview descriptions of the technological state of the art. Together they constitute a definitive view of research and applications for use by scientists, users, and associated organizations.
Cooperation with CCITT (Commite Consultatif International pour Telephonie et Telegraphic -- a technical body of the International Telegraphics Union which makes recommendations for worldwide standards in the area of telecommunications) has been instituted by the IFIP Technical Committee studying Data Communications. One of the specialized working groups of TC6 coordinates research to clarify the problems and options for the international interconnection of packet switched networks. Results of this research are made available to Study Group VII of CCITT which is deliberating on the facilities and appropriate standards for new data networks (of which packet switched networks are only one type).
Efficient demultiplexing of incoming TCP packets
Authors: McKenney Paul E. , Dove Ken F. 
Published: October 2004

When a transport protocol segment arrives at a receiving system, the receiving system must determine which application is to receive the protocol segment. This decision is typically made by looking up a protocol control block (PCB) for the segment, based on information in the segment's header. PCB lookup (a form of demultiplexing) is typically one of the more expensive operations in handling inbound protocol segment [Fe190].
Many recent protocol optimizations for the Transmission Control Protocol (TCP) [Jac88] assume that a large component of TCP traffic is bulk-data transfers, which result in packet trains [JR86]. If packet trains are prevalent, there is a high likelihood that the next TCP segment is en route to the same application (i.e. uses the same PCB) as the previous TCP segment. In these environments a very simple one-PCB cache like those used in BSD systems yields very high cache hit rates.
However, there are classes of applications that do not form packet trains, and these applications do not perform well with a one-PCB cache. Examples of such applications are quite common in the area of heads-down data entry into on-line transaction-processing (OLTP) systems. OLTP systems make heavy use of computer communications networks and have large aggregate-packet-rates but are also characterized by large numbers of connections, low per-connection packet rates, and rather small packets. This combination of characteristics results in a very low incidence of packet trains.
This paper uses a simple analytic approach to examine how different PCB lookup schemes perform with OLTP traffic. One scheme is shown to work an order of magnitude better for OLTP traffic than the one-PCB cache approach while still maintaining good performance for packet-train traffic.
A survey of UNI signaling systems and protocols for ATM networks
Authors: Stiller Burkhard 
Published: October 2004

The main aspect covered by signaling systems and protocols for ATM networks concerns the possibility to manage, maintain, and control a user-driven communication between arbitrary ATM end-systems connected to an ATM network. The tasks and procedures defined for, e.g., setting-up an ATM connection, are often very different concerning the rrelevant specifications of various working bodies (such as ITU-T or ATM-Forum) or certain vendors, although the basis to be done for maintaining ATM connections are always principally the same. The reason for this situation is, that the intentions of working bodies are different and each one of them follows specific strategies for certain scenarios (such as for point-to-point unicast or point-to-multipoint multicast). Nevertheless, various types of characteristics (such as addressing, multicast, or interworking) are requested from applications residing on top of ATM networks.
Therefore, this survey of signaling systems and protocols for ATM networks identifies for several of selected approaches (such as Q.2931, UNI 3.1, or CMAP) important characteristics and relevant scenarios. Furthermore, a table-based comparison of some approaches has been added
Review of Isomorphisms of Types:
Authors: League Christopher 
Published: October 2004

The λ-calculus is an elegant computational model used
extensively in the formal semantics of programming languages. It
was first described by Alonzo Church in 1932, as a foundation of
mathematics based not on
sets,
but directly on
functions.
λ-calculus was, in part, the inspiration
for the programming language Lisp, and its typed versions have
become the foundation for a family of modern type-safe languages
that includes Haskell and ML.

In its original untyped form, the λ-calculus is an
extremely simple rewrite system with the concise syntax
e
::
x
|
e
1
e
2
|λ
x.e,
where
x
ranges over
variable names,
e
1
e
2
is called
an
application,
and λ
x.e
is called an
abstraction.
An abstraction is analogous to a
function;
x
is the
formal parameter
and
e
is the
body.
Effectively, there is just one rewrite rule, called
β-reduction: (λ
x.e
1
)
e
2
→β
e
1
[
e
2/
x
], where
e
1
[
e
2
/
x
] means that we
substitute e
2
for occurrences of
x
in the
expression
e
1
Voilà---Turing
equivalence.

Actually, there are a few technicalities we are glossing over,
having to do with renaming bound variables and such. And in modern
usage we generally augment the system with natural numbers,
arithmetic, and boolean logic as primitives, although these can be
completely encoded in the raw calculus.

This book is about
types
(a familiar notion in both
mathematical logic and programming languages) and a family of
typed
λ-
calculi.
Armed with these formalisms,
Di Cosmo explores various
isomorphisms
of types, which then
prove useful in building a software engineering tool to classify
and retrieve software components! Specifically,

" Chapters 1-3 present a quick introduction to the various typed
λ-calculi, sketch some isomorphisms, and then prove
important results about confluence, decidability, and
normalization.
" Chapters 4-5 contain the meat of the theoretical contribution
of this work, presenting complete theories for first- and
second-order isomorphic types.
" Chapters 6-7 demonstrate the utility of these isomorphisms in
a software engineering application, and sketch other potential
applications and extensions.
Line operations network growth issues (panel session, abstract only)
Authors: White G. D. 
Published: October 2004

The task of keeping customer impact to a minimum while attempting to grow, modernize and improve the network in todays packet switching environment is becoming increasingly more difficult. As the network evolves and the customer demand for higher network availability increases, the need for line operations personnel to reduce customer impact has presented a unique challenge for innovative ideas to accomplish this objective.
Although the equipment supplier may provide excellent technical documentation for the provisioning, testing and maintenance of their products, they cannot provide the means to administer, manage and control a large network. This is the sole area where the network provider is responsible for deciding how his network will impact the customer.
This presentation will deal with some of the operational problems encountered in growing a network from 5 nodes to 55 nodes over a period of 9 years. Some of the subject areas that will be covered are: the maintenance window - is it required?; administrative documentation; utilization of network statistics; hardware retrofits; and software updates - major and minor. These are but a few of the problem areas challenging packet switching network providers today. Their resolution are limited only by the imagination of the personnel charged with the responsibility of resolving them.
Operations considerations in a large privated packet switching network
Authors: Stubbs R. D. , Swymer L. Dee , Quinn T. L. 
Published: October 2004

In early 1977, Southern Bell began to study ways to reduce terminal and leased line costs associated with internal computer communications. Because a large volume of these communications were of an asynchronous, character-mode nature, packet switching emerged as the most attractive solution to reducing these costs. In May, 1979, the first application went on-line with one switch, one host concentrator and three terminal concentrators. Operation of this network was simple, with operations and planning residing in the same work group.
Today, the network consists of twenty tandem switches, 185 local switches and 85 packet assembler/disassemblers, interconnected by 15,928 miles of trunk facilities. The network architecture has evolved to geographically distributed “principle switching points” interconnected through a single major switching center in Atlanta, Georgia. Each “principle switching point” serves an area of company interest by supporting a number of local switches and concentrators.
As the complexity of the network has increased, so has the complexity of network operation. Operations have been both functionally and geographically differentiated to keep up with the evolution of the network, and to stay consistent with changing packet switch architecture. This talk will cover the network operations and maintenance considerations associated with the operation of today's very large network.
Trajectory sampling for direct traffic observation
Authors: Duffield N. G. , Grossglauser M. 
Published: October 2004

Traffic measurement is a critical component for the control and engineering of communication networks. We argue that traffic measurement should make it possible to obtain the spatial flow of traffic through the domain, i.e., the paths followed by packets between any ingress and egress point of the domain. Most resource allocation and capacity planning tasks can benefit from such information. Also, traffic measurements should be obtained without a routing model and without knowledge of network state. This allows the traffic measurement process to be resilient to network failures and state uncertainty.
We propose a method that allows the direct inference of traffic flows through a domain by observing the trajectories of a subset of all packets traversing the network. The key advantages of the method are that (i) it does not rely on routing state, (ii) its implementation cost is small, and (iii) the measurement reporting traffic is modest and can be controlled precisely. The key idea of the method is to sample packets based on a hash function computed over the packet content. Using the same hash function will yield the same sample set of packets in the entire domain, and enables us to reconstruct packet trajectories.
When the CRC and TCP checksum disagree
Authors: Stone Jonathan , Partridge Craig 
Published: October 2004

Traces of Internet packets from the past two years show that between 1 packet in 1,100 and 1 packet in 32,000 fails the TCP checksum, even on links where link-level CRCs should catch all but 1 in 4 billion errors. For certain situations, the rate of checksum failures can be even higher: in one hour-long test we observed a checksum failure of 1 packet in 400. We investigate why so many errors are observed, when link-level CRCs should catch nearly all of them.
We have collected nearly 500,000 packets which failed the TCP or UDP or IP checksum. This dataset shows the Internet has a wide variety of error sources which can not be detected by link-level checks. We describe analysis tools that have identified nearly 100 different error patterns. Categorizing packet errors, we can infer likely causes which explain roughly half the observed errors. The causes span the entire spectrum of a network stack, from memory errors to bugs in TCP.
After an analysis we conclude that the checksum will fail to detect errors for roughly 1 in 16 million to 10 billion packets. From our analysis of the cause of errors, we propose simple changes to several protocols which will decrease the rate of undetected error. Even so, the highly non-random distribution of errors strongly suggests some applications should employ application-level checksums or equivalents.
Scale and performance in a distributed file system
Authors: Howard J. , Kazar M. , Menees S. , Nichols D. , Satyanarayanan M. , Sidebotham Robert N. , West M. 
Published: October 2004

Andrew is a distributed computing environment being developed in a joint project by Carnegie Mellon University and IBM. One of the major components of Andrew is a distributed file system which constitutes underlying mechanism for sharing information. The goals of the Andrew file system are to support growth up to at least 7000 workstations (one for each student, faculty member, and staff at Carnegie Mellon) while providing users, application programs, and system administrators with the amenities of a shared file system.
A fundamental result of our concern with scale is the design decision to transfer whole files between servers and workstations rather than some smaller unit such as records or blocks, as almost all other distributed file systems do. This paper examines the consequences of this and other design decisions and features that bear on the scalability of Andrew.
Large scale affects a distributed system in two ways: it degrades performance and it complicates administration and day-to-day operation. This paper addresses both concerns and shows that the mechanisms we have incorporated cope with them successfully. We start the initial prototype of the system, what we learned from it, and how we changed the system to improve performance. We compare its performance with that of a block-oriented file system, Sun Microsystems' NFS, in order to evaluate the whole file transfer strategy. We then turn to operability, and finish with issues related peripherally to scale and with the ways the present design could be enchanced.
The packer filter: an efficient mechanism for user-level network code
Authors: Mogul J. , Rashid R. , Accetta M. 
Published: October 2004

Code to implement network protocols can be either inside the kernel of an operating system or in user-level processes. Kernel-resident code is hard to develop, debug, and maintain, but user-level implementations typically incur significant overhead and perform poorly.
The performance of user-level network code depends on the mechanism used to demultiplex received packets. Demultiplexing in a user-level process increases the rate of context switches and system calls, resulting in poor performance. Demultiplexing in the kernel eliminates unnecessary overhead.

This paper describes the
packet filter
, a kernel-resident, protocol-independent packet demultiplexer. Individual user processes have great flexibility in selecting which packets they will receive. Protocol implementations using the packet filter perform quite well, and have been in production use for several years.
The duality of memory and communication in the implementation of a multiprocessor operating system
Authors: Young M. , Tevanian A. , Rashid R. , Golub D. , Eppinger J. 
Published: October 2004

Mach is a multiprocessor operating system being implemented at Carnegie-Mellon University. An important component of the Mach design is the use of memory objects which can be managed either by the kernel or by user programs through a message interface. This feature allows applications such as transaction management systems to participate in decisions regarding secondary storage management and page replacement.
This paper explores the goals, design and implementation of Mach and its external memory management facility. The relationship between memory and communication in Mach is examined as it relates to overall performance, applicability of Mach to new multiprocessor architectures, and the structure of application programs.
Reimplementing the Cedar file system using logging and group commit
Authors: Hagmann R. 
Published: October 2004

The workstation file system for the Cedar programming environment was modified to improve its robustness and performance. Previously, the file system used hardware-provided labels on disk blocks to increase robustness against hardware and software errors. The new system does not require hardware disk labels, yet is more robust than the old system. Recovery is rapid after a crash. The performance of operations on file system metadata, e.g., file creation or open, is greatly improved.
The new file system has two features that make it atypical. The system uses a log, as do most database systems, to recover metadata about the file system. To gain performance, it uses group commit, a concept derived from high performance database systems. The design of the system used a simple, yet detailed and accurate, analytical model to choose between several design alternatives in order to provide good disk performance.
Where is time spent in message-passing and shared-memory programs?
Authors: Chandra Satish , Larus James R. , Rogers Anne 
Published: October 2004

Message passing and shared memory are two techniques parallel programs use for coordination and communication. This paper studies the strengths and weaknesses of these two mechanisms by comparing equivalent, well-written message-passing and shared-memory programs running on similar hardware. To ensure that our measurements are comparable, we produced two carefully tuned versions of each program and measured them on closely-related simulators of a message-passing and a shared-memory machine, both of which are based on same underlying hardware assumptions.
We examined the behavior and performance of each program carefully. Although the cost of computation in each pair of programs was similar, synchronization and communication differed greatly. We found that message-passing's advantage over shared-memory is not clear-cut. Three of the four shared-memory programs ran at roughly the same speed as their message-passing equivalent, even though their communication patterns were different.
Simple compiler algorithms to reduce ownership overhead in cache coherence protocols
Authors: Skeppstedt Jonas , Stenström Per 
Published: October 2004

We study in this paper the design and efficiency of compiler algorithms that remove ownership overhead in shared-memory multiprocessors with write-invalidate protocols. These algorithms detect loads followed by stores to the same address. Such loads are marked and constitute a hint to the cache to obtain an exclusive copy of the block. We consider three algorithms where the first one focuses on load-store sequences within each basic block of code and the other two analyse the existence of load-store sequences across basic blocks at the intra-procedural level. Since the dataflow analysis we adopt is a trivial variation of live-variable analysis, the algorithms are easily incorporated into a compiler.
Through detailed simulations of a cache-coherent NUMA architecture using five scientific parallel benchmark programs, we find that the algorithms are capable of removing over 95% of the separate ownership acquisitions. Moreover, we also find that even the simplest algorithm is comparable in efficiency with previously proposed hardware-based adaptive cache coherence protocols to attack the same problem.
Early experience with Mesa
Authors: Geschke Charles M. , Morris James H. , Satterthwaite Edwin H. 
Published: October 2004

The experiences of Mesa's first users—primarily its implementers—are discussed, and some implications for Mesa and similar programming languages are suggested. The specific topics addressed are:
module structure and its use in defining abstractions,
data-structuring facilities in Mesa,
equivalence algorithm for types and type coercions,
benefits of the type system and why it is breached occasionally,
difficulty of making the treatment of variant records safe.
Topological analysis of local-area internetworks
Authors: Trewitt G. 
Published: October 2004

It has become common to connect local-area networks together to form high-bandwidth internetworks. The topology of such an internetwork — how the component networks and gateways are interconnected — is an important factor in determining the reliability of the internet. We present several techniques for analyzing an internetwork's topology. These techniques are based on a novel mapping of network components onto a bipartite graph.
We use these techniques to analyze the topology of the Stanford University Network and the impact of topological changes as it has grown to its current size of 60 networks.
Pitfalls in the design of distributed routing algorithms
Authors: Perlman R. , Varghese G. 
Published: October 2004

The bridge algorithm adopted by the IEEE 802.1 committee for interconnecting 802 LANs requires the topology of the Extended LAN to be a Spanning Tree. A distributed algorithm to compute a spanning tree dynamically has already been published [1], and adopted by the IEEE 802.1 committee [2]. In this paper, however, we describe an alternative distributed algorithm to compute a spanning tree. This algorithm, variants of which have been implemented, initially appears simpler than the IEEE 802.1 algorithm; we show, however, that it has subtle failure modes that makes it unattractive in practice.
We also show that some failure modes of the Spanning Tree Algorithm introduced in this paper are characteristic of a broader class of distributed graph algorithms. Such algorithms potentially examine all possible path combinations between a source and destination in a graph. Thus, they suffer from exponential message overhead in topologies that have an exponential number of paths between source and destination. Attempts to fix this problem lead to extra complexity (in terms of CPU, bandwidth, memory) when compared to other algorithms. We briefly describe a second example belonging to this class, and propose that designers avoid such algorithms if restricting the topology or scale of the network is unacceptable.