FABRIC is a national and international scale research infrastructure built to enable cutting-edge research in a wide range of networking and computing areas and domain sciences that depend on advanced networking and computing capabilities. Since its full operation in October 2023, FABRIC has seen rapidly emerging experiments in different research topics. This paper provides a description of FABRIC’s hardware resources, software services, and an analysis of the characteristics of the emerging experiments that are leveraging FABRIC’s unique capabilities. The analysis showed a wide spectrum of topic areas, frequent emphasis on at-scale and high performance experiments that interact with real facilities and real people, and growing complexity and rigor in tools, data and measurement. Researchers are seen sharing well-developed artifacts with others to enable larger experiments and reproducible research.

Network security policies provide high-level directives regarding acceptable and unacceptable use of the network. Organizations specify these high-level directives in policy documents written using human-readable natural language. The challenge is to convert these natural language policies to the network configurations/specifications needed to enforce the policy. Network administrators, who are responsible for enforcing the policies, typically translate the policies manually, which is a challenging and error-prone process. As a result, network operators (as well as the policy authors) often want to verify that network policies are being correctly enforced. In this paper, we propose Network Policy Conversation Engine (NPCE), a system designed to help network operators (or policy writers) interact with the network using natural language (similar to the language used in the network policy statements themselves) to understand whether policies are being correctly enforced. The system leverages emerging big data collection and analysis techniques to record flow and packet level activity throughout the network that can be used to answer users policy questions. The system also takes advantage of recent advances in Natural Language Processing (NLP) to translate natural language policy questions into the corresponding network queries. To evaluate our system, we demonstrate a wide range of policy questions – inspired by actual networks policies posted on university websites – that can be asked of the system to determine if a policy violation has occurred.

Network policies govern the use of an institution's networks, and are usually written in a high-level human-readable natural language. Normally these policies are enforced by low-level, technically detailed network configurations. The translation from network policies into network configurations is a tedious, manual and error-prone process. To address this issue, we propose a new intermediate language called POlicy LANguage for Campus Operations (POLANCO), which is a human-readable network policy definition language intended to approximate natural language. Because POLANCO is a high-level language, the translation from natural language policies to POLANCO is straightforward. Despite being a high-level human readable language, POLANCO can be used to express network policies in a technically precise way so that policies written in POLANCO can be automatically translated into a set of software defined networking (SDN) rules and actions that enforce the policies. Moreover, POLANCO is capable of incorporating information about the current network state, reacting to changes in the network and adjusting SDN rules to ensure network policies continue to be enforced correctly. We present policy examples found on various public university websites and show how they can be written as simplified human-readable statements using POLANCO and how they can be automatically translated into SDN rules that correctly enforce these policies.

A key concept of software-defined networking (SDN) is separation of the control and data plane. This idea provides several benefits, including fine-grained network control and monitoring, and the ability to deploy new services in a limited scope. Unfortunately, it is often cost-prohibitive for enterprises (and universities in particular) to upgrade their existing networks to wholly SDN-capable networks all at once. A compromise solution is to deploy SDN capabilities incrementally in the network. The challenge then is to take full advantage of SDN-based services throughout the network, in an integrated fashion rather than in a few "islands" of SDN support. At the University of Kentucky, SDN has been integrated into the campus network for several years. In this paper, we describe two aspects of this challenge, along with our solution approaches. One is the general reluctance of campus network administrations to allow novel or experimental (SDN-based) services in the production network. The other is how to extend such services throughout the legacy part of the network. For the former, we lay out a set of principles designed to ensure that the production service is not harmed. For the latter, we use policy based routing and a graph database to extend our previously-described VIP Lanes service. Our simulation results in a campus-like topology testbed show that we can provide a host with custom path service even if it is connected to a legacy router.

In this paper we consider an alternative possibility for routing money in the Internet ecosystem based on a spot market for interconnection service that operates alongside, or in addition to, the traditional contract service model. Recent work by others showed that under certain assumptions, enabling transit providers (i.e., networks that carry packets between networks) to sell their excess capacity on a best-effort basis improves both provider profit and consumer surplus. While prior work only focused on pricing strategies, we explore the technical feasibility of such a market in this paper. We consider what is needed to make such a spot market possible and focus on the interaction between technical and economic considerations. In particular, we describe two approaches that demonstrate how economic software defined exchanges (ESDXs) can be used as trusted intermediaries to tie the forwarding service to the flow of money.

Campus networks and enterprise networks increasingly depend on middleboxes (e.g., firewalls, NAT, load balancers, IDS/IDP) to provide essential services or enforce network policies. These middleboxes often limit the performance of network applications, especially those involved in big data transfer. To address this problem, we propose a Software Defined Networking (SDN) campus network architecture, called VIP Lanes, that provides the ability for pre-authorized, trusted users to create flows that bypass middleboxes, thereby enabling those users to achieve substantially better performance while maintaining security and policy compliance for other network traffic. In this paper, we present the VIP Lanes abstraction and describe an authorization and policy-enforcement service used to establish trusted VIP Lanes. We describe an initial prototype implementation that not only demonstrates the viability of the VIP Lanes approach, but also gives an indication of the types of performance improvements that are possible - in some cases approaching a two order of magnitude reduction in transmission times.

Internet Exchange Points (IXPs) play a major role in the current Internet architecture, serving as the connection point between Internet Service Providers (ISPs). Software-Defined Exchange Points (SDXs)-programmable versions of Internet Exchange Points (IXPs)-have been proposed as a way to give ISPs finer-grained control over the way packets are routed between ISPs. Leveraging software-defined networking (SDN) technology, an SDX enables control software to insert forwarding rules that route traffic on the granularity of individual flows. In this paper, we describe work-in-progress developing controllers for Software-Defined Internet Exchange Points that facilitate dynamic establishment of forwarding relationships between transit ISPs. The core hypothesis of our work is that the SDX can serve as a trusted intermediary, both facilitating establishment of dynamic peering agreements between ISPs, and enforcing their routing policies. Moreover, this building block, which we dub the Coin-Operated SDX, can be used to construct much more dynamic and fine-grained end-to-end routing services than are possible in today's infrastructure. In our model, each ISP independently but cooperatively defines the policies that the SDX enforces on its behalf. The SDX may also serve as a clearinghouse for the inter-ISP economic transactions that drive these policies, i.e., as Economic SDX (ESDX). We describe the overall architecture of a Coin-Op SDX, as well as the specific operations it must support to offer dynamic services. We believe that Coin-Op SDX can play a critical role in future software-defined inter-domain Internet infrastructure.

Deployment of innovative new networking services requires support by network providers. Since economic motivation plays an important role for network providers, it is critical that a network architecture intrinsically considers economic relationships. We present the design of a protocol that associates access to network services with economic contracts. We show how this protocol can be realized in fundamentally different ways, using out-of-band signaling and in-band signaling, based on two different prototype implementations. We present results that show the effectiveness of the proposed protocol and thus demonstrate a first step toward realizing an economy plane for the Internet.

Unlike the current Internet where applications have little control over the path that their data travels, emerging network architectures enable applications to control the path their packets/flows take. Although an application can select its paths, providing an application with the up-to-date information needed to make an informed decision is a difficult problem. In particular, monitoring (i.e., collecting performance information about) a network the size of the Internet presents serious scalability challenges. In this paper, we present a network monitoring service that can provide applications with up-to-date network information, yet scale to the size of the Internet. Our network monitoring service dynamically selects and enables/disables monitoring points to focus on paths currently needed by applications. We present experimental results based on real-world traffic traces that show our system can provide up-to-date information for 80% of the paths used by applications by monitoring as few as 100 strategically identified locations in the Internet.

Test beds such as GENI provide an ideal environment for experimenting with future internet architectures such as Choice Net. Unlike the narrow waist of the current Internet (IP), Choice Net encourages alternatives and competition at the network layer via an economic plane that allows users to choose and purchase precisely the services they need. In this paper we describe our experiences implementing the Choice Net architecture on GENI. Some features of GENI, such as the ability to program the network layer, to leverage existing protocols and software, to run real applications generating realistic traffic, and the ability to perform long-running experiments made GENI an ideal platform for Choice Net experimentation. However, we found that GENI currently lacks the tools needed to make it easy to use these features. To address this issue, we designed and implemented a GENI Experimenter Tool specifically designed and tailored to perform tasks commonly needed by experimenters such as dynamically configuring nodes, loading and compiling node-specific code, executing Click modules, running commands on sets of nodes, accessing the local file system on nodes, and dynamically logging into nodes.

Recent research has considered various architectural approaches in which route determination occurs separately from forwarding. Such offers many advantages, but also brings a number of challenges, not least of which is scalability. In this paper we consider the problem of computing domain-level end-to-end routes in the Internet. We describe a system architecture and a prototype route computation service that provides performance information along with paths. The results of our experiments, which involve updating billions of routes and serving thousands of requests per second, suggest that the resource requirements for a single-domain end-to-end path service (i.e., a service that provides paths from one access domain to all others) are fairly modest.

Software-Defined Networking (SDN) has been widely recognized as a promising way to deploy new services and protocols in future networks. The programmability and control offered by SDN networks enables users and applications to define virtually every aspect of the network architecture. Unfortunately, this flexibility comes at a cost - a cost that has the potential to significantly limit its adoption. First, in order to offer complete flexibility, today's SDN networks provide low-level API's on which almost any type of service can be written. In the process, it can actually become more difficult to implement the higher level complex services needed by future networks. Second, emerging SDN networks exhibit a heterogeneity reminiscent of the early Internet, with limited ability to piece together the various SDN platforms being deployed. In this paper we propose a new way to construct SDN networks consisting of multiple SDN providers offering virtualizable networking resources across the Internet. At the heart of our approach is a Network Hypervisor service that is capable of internetworking various SDN providers together. Moreover, our Network Hypervisor builds on the low-level APIs provided by SDNs to create a unified set of high-level abstractions and APIs that greatly simplify the task of building and deploying complex network services over SDN.

Network virtualization is becoming a fundamental building block of future Internet architectures. Although the underlying network infrastructure needed to dynamically create and deploy custom virtual networks is rapidly taking shape (e.g., GENI), constructing and using a virtual network is still a challenging and labor intensive task, one best left to experts.

To address shortcomings of the current Internet, many researchers are taking a clean-slate approach toward re-designing the Internet. These so-called clean-slate approaches discard the old assumptions, design principles, and constraints of the current Internet, set aside concerns about compatibility with existing software, and rebuild the entire network from scratch. Clean-slate approaches have the potential to produce a completely new Internet with new features and applications. However, clean-slate approaches are rarely backward compatible, thereby rendering existing legacy software and applications useless. Rewriting huge numbers of existing legacy applications to run in a clean-slate environment is simply not practical. This paper attempts to address this challenge of running legacy software on a clean-slate network architecture. We propose a general framework that supports a translation and policy interface by which users and administrators (or applications) can map legacy software onto emerging clean-slate networks. Using the framework, users are able to take advantage of the features of a clean-slate network while running existing applications. To check the correctness and completeness of our framework, we implemented an initial prototype and applied it in the context of our clean-slate Postmodern (PoMo) Internet Architecture. Using our system we show how existing applications can make use of, and benefit from, PoMo's multi-path routing capabilities.

Much of the GENI effort in developing network testbeds has been focused on building the control frameworks needed to allocate and initialize the network resources that make up an experiment. We argue that building the instrumentation and measurement system to monitor and capture the behavior of the network is just as important and challenging as setting up the network itself, especially in a virtualized and federated environment where getting information from experimental nodes is too complicated and too much to handle for a typical user. In this paper, we describe the design of an instrumentation and measurement infrastructure that allows users to monitor their experiments. The challenge that virtualization and federation of GENI testbeds bring to instrumentation and monitoring is how to hide the details of instrumentation setup from users so that users do not need to be experts in system administration or network management of virtualized and federated systems, but are still able to “see” what is going on with their experiments. Our instrumentation tool sets up experiment-specific monitoring infrastructure that is tailored to capture, record, and display only information associated with that experiment. Our tools are currently available in GENI, and we present a simple example of how to use them to instrument an experiment.

A common feature of emerging future Internet architectures is the ability for applications to select the path, or paths, their packets take between the source and destination. Unlike the current Internet architecture where routing protocols find a single (best) path between a source and destination, future Internet routing protocols will need to present applications with a choice of paths. Even if the routing service can return a list of possible paths, the huge number of potential paths and the need to know the current network conditions of each of the proposed paths will make it virtually impossible for applications to select the best set of paths, or just the best path. In this paper, we present a new network path advising service (NPAS) that helps future applications choose network paths. Given a set of possible paths, the NPAS service helps applications select appropriate paths based on both recent path measurements and end-to-end feedback collected from other applications. We describe the NPAS service abstraction, API calls, and a distributed architecture that achieves scalability by determining the most important things to monitor based on actual usage. Finally, we describe a prototype implementation of the NPAS service.

There has been a great interest in defining a new network architecture that can meet the needs of a future Internet. One of the main challenges in this context is how to realize the many different technical solutions that have developed in recent years in a single coherent architecture. In addition, it is necessary to consider how to ensure economic viability of architecture solutions. In this work, we discuss how to design a network architecture where choices at different layers of the protocol stack are explicitly exposed to users. This approach ensures that innovative technical solutions can be used and rewarded, which is essential to encourage wide deployment of this architecture.

In the current Internet architecture, functions such as addressing, routing, and forwarding are entangled. Among other consequences, this makes it difficult to modify one without affecting the others, and obscures the role of policy at various places in the architecture. This paper considers a network layer designed as a set of separable component mechanisms that work together to provide a best-effort datagram service. Our thesis is that separating concerns makes the architecture more flexible and robust. After presenting the functions that make up the recursive (hierarchical) routing and forwarding service, we discuss the initialization process. The separation and delegation of functions, along with the use of flat, topology-independent identifiers, allows the architecture to be self-configuring as much as possible, leaving the components whose function is affected by policy to be configured.

Emulabs, network testbeds on which experiments can be carried out through a web interface, are widely recognized as useful research environments. We believe that Emulabs are also excellent platforms for teaching courses in operating systems and networking. Moreover, equipment costs have fallen, and Emulab software has evolved, to the point where any school could conceivably afford their own. This raises the obvious question: "Should institutions build and operate their own Emulab?". To get a handle on this question, we describe our experiences building and operating Edulabs--Emulabs specifically designed for education--at Calvin College and the University of Kentucky. We argue that with the right technical support, owning and operating one's own Emulab is a worthwhile endeavor that has many benefits. We acknowledge, however, that in the absence of good technical support, deploying one's own Emulab can be a difficult enterprise. We also describe how we enhanced Emulab to improve its utility in an educational setting.

We present a ”clean-slate” design for a network-layer routing and forwarding system intended to address short-comings of the current Internet Protocol. Our design separates routing from both forwarding and topology discovery; requires only a flat, topology-independent namespace; and allows for policies of both users and service providers to be supported. Channels serve as the primary abstraction, allowing the network topology to be viewed at multiple levels of abstraction using the same identifiers. In this paper we present the basic design, which is based on loose source routing. Our routing and forwarding scheme is part of a larger project to produce a “clean-slate” network layer design.

We study the problem of building an optimal network-layer clustering hierarchy, where the optimality can be defined using three potentially conflicting metrics: state, delay and bandwidth. The problem of network clustering where a node's addresses depends on the node's location (e.g. in the hierarchy) is well studied. We study a problem where network nodes are addressed by specifications that might not be tied to locations in the topology. We propose and compare several distributed clustering algorithms: (i) clustering based solely on topology, (ii) clustering based solely on semantics (node specifications) and (iii) a combination of the above methods (toposemantic network clustering), where we specify a parameter that determines how much the clustering depends on topology and how much on semantics. We show that the toposemantic method yields the best results when we know the right parameter value for a given topology and assignment of specifications. We propose an algorithm that does not require a parameter, but nevertheless yields better results than the first two methods.

We consider the problem of choosing multiple paths across an overlay network in order to provide applications with high-throughput data transfer. Approaches based on traditional (link state) routing algorithms involve a substantial (quadratic) overhead for exchange of state information in fully-connected overlays. Moreover, in the absence of coordination, an apparently "good" link may be selected by multiple sessions simultaneously, causing it to become congested. The simple solution-more frequent exchange of state information-only exacerbates the overhead problem. We present an alternative algorithm that uses a lazy approach to collect link state information, and computes paths by finding the intersection of sets of candidate intermediate hops. Results from experiments show that this intersection-based approach produces paths that provide better performance, has significantly lower overhead, and distributes load more evenly through the network than link-state alternatives.

The Metaverse project aims to develop technology for low-cost, high-resolution networked immersive display environments that can be used for distributed collaboration, exploration of 3D data models, scientific visualization, and other Grid-related applications. Such applications often deal with massive data sets and need a high-capacity, low-latency transport service to effectively connect distant locations across the wide-area (best-effort) Internet. This work presents the initial design of such an end-to-end transport service for Metaverse applications, along with results of a simulation study evaluating its effectiveness. The transport service features an application programming interface providing enhanced control over the way resources are allocated to data objects, and uses multiple overlay-based end-to-end paths to increase bandwidth delivered to the application.

Emerging network-level services, such as ephemeral state processing (ESP), provide end systems with the ability to control the way in which their packets are processed at routers in the network. Supporting user-defined per-packet processing at today's wire-speeds requires significant computational power. Special-purpose application specific integrated circuit (ASIC) chips offer the performance, but not the extensibility needed to support these, evolving services. In our previous work, we explored the use of programmable (general-purpose) network processors as a potential solution. Although network processors are easily extensible, they pay a performance penalty for that flexibility. In this paper, we explore a third approach; the use of programmable logic devices (PLD) that combine the flexibility of a network processor with the performance of an ASIC. We describe a PLD implementation of the ESP service, discuss the challenges involved, and present performance numbers showing significant speedups over our previous network processor implementation.

We describe a new network service called speccast. Speccast offers a generalized addressing and routing abstraction on which a rich variety of semantic services can be built, and, as such, provides a vehicle for studying the relationships among routing, addressing and topology. Unlike overlay-based systems, we study a more basic problem, in which the topology of the network is given, and there is not necessarily any pre-existing underlying network service. In the speccast model, each packet carries a destination predicate and the network's job is to deliver the packet to all nodes satisfying that predicate. After showing how this generalized routing service subsumes other services both traditional (unicast, multicast) and emerging (publish-subscribe), we present a layered solution for a specific class of simple predicates. We examine the tradeoffs in various forms of our approach, and compare it to existing solutions for unicast and multicast. Studies using transit-stub graphs show that our generic service performs comparably to existing solutions for traditional services, while also effectively supporting new and emerging services.

Overlays have been proposed as a means to improve application performance in many areas, including multimedia streaming and content distribution. Some overlays use parallel transmission to increase aggregate throughput or use backup paths to improve reliability. For such applications, an important consideration is whether the "virtual links" at the overlay level (i.e. paths between overlay nodes) share links in the underlying network. In particular, choosing parallel or backup paths without any information about path correlation can reduce the effectiveness of the overlay.In this paper we show how to use passive measurement of TCP throughput to provide information about path correlation, for use in overlay routing decisions. Our methods have the advantage that they send no probe traffic to collect path information. We present results of experimental evaluation in both controlled testbed (Emulab) and real wide area network (Planetlab). Our results demonstrate that the methods together work well across a wide range of operating conditions.

One of the challenges in reliable multicast is approximating or replicating TCP's congestion control algorithm. This has led to various proposals to adapt TCP itself for use over multicast. The drawback of these multicast TCP services is that they place significant processing load on the sender and they fail to deal with the problem of ACK implosion. This paper shows how concast, a network-layer aggregation service, can be used in conjunction with a standard (unmodified) TCP implementation to support reliable multicast while avoiding ACK implosion and offloading ACK processing. Our prototype implementation shows that, even for relatively small groups, distributing the ACK processing and reducing ACK losses translates into significant improvements in end-to-end transmission rates.

Abstract Multicast services have been used to transmit multimedia data to large receiver groups. Only recently have counterpart network services been introduced to provide similar scalability and anonymity in the opposite direction (i.e. messages from a group of senders destined for a common receiver). In this paper, we explore how these many‐to‐one services, specifically the concast service, can be used to improve the scalability and performance of multimedia applications. In particular, we show how such services can be used in both the control and data planes to overcome well‐known scalability problems (e.g. with Real Time Protocol) that are difficult to solve effectively with end‐system approaches alone. We validate our solutions by presenting experimental results taken from prototype video and audio applications we designed and implemented. Our initial results show substantial reductions in congestion‐induced loss using these generic services. Copyright © 2003 John Wiley & Sons, Ltd.

Enhanced network services often involve allocating resources (bandwidth/buffer space) preferentially to packets belonging to certain flows or traffic classes. Such services are vulnerable to denial-of-service attacks if packet classification is based on information that can be forged, such as source and destination addresses and port numbers. Traditional message authentication codes (MACs), often considered the only solution to this problem, are really not designed to solve it. In particular, their per-packet costs are so high that they enable another form of denial-of-service attack based on overwhelming the verification mechanism. We describe the problem of denial of access to reserved resources and the inadequacies of conventional solutions. We then observe that it is reasonable to trade some of the strong security guarantees provided by conventional MACs for a lower per-packet cost. We propose a new packet authentication algorithm, designed to solve the problem of protecting reserved resources, with a very low, fixed per-packet cost. While it cannot replace conventional MACs for end-to-end authentication, we argue that it is a better solution for the problem considered here. We present measurements from a prototype implementation that can verify a packet of arbitrary size in as few as 1000 machine cycles on an Intel architecture machine.

Some end-to-end network services benefit greatly from network support in terms of utility and scalability. However, when such support is provided through service-specific mechanisms, the proliferation of one-off solutions tend to decrease the robustness of the network over time. Programmable routers, on the other hand, offer generic support for a variety of end-to-end services, but face a different set of challenges with respect to performance, scalability, security, and robustness. Ideally, router-based support for end-to-end services should exhibit the kind of generality, simplicity, scalability, and performance that made the Internet Protocol (IP) so successful. In this paper we present a router-based building block called ephemeral state processing (ESP), which is designed to have IP-like characteristics. ESP allows packets to create and manipulate small amounts of temporary state at routers via short, predefined computations. We discuss the issues involved in the design of such a service and describe three broad classes of problems for which ESP enables robust solutions. We also present performance measurements from a network-processor-based implementation.

Multicast services have been used for many years to transmit multimedia data to large receiver groups. However, only recently have counterpart network services been introduced that provide similar scalability and anonymity in the opposite direction (i.e., messages from a group of senders destined for a common receiver). In this paper, we explore how these emerging services, specifically a concast service (many-to-one communication service), can be used to improve the scalability and performance of multimedia applications. In particular, we show how such services can be used in both the control and data planes to overcome well-known scalability problems (e.g., with RTP) that are difficult to solve effectively with end-system approaches alone. We validate our solutions by presenting experimental results taken from prototype video and audio applications we designed and implemented. Our initial results show a reduction of as much as two orders of magnitude in packet loss rates using these generic services.

Concast is a network layer service that provides many-to-one channels: multiple sources send messages toward one destination, and the network delivers a single "merged" copy to that destination. As we have defined it, the service is generic but the relationship between the sent and received messages can be customized for particular applications. We describe the concast service and show how it can be implemented in a back ward-compatible manner in the Internet. We describe its use to solve a problem that has eluded scalable end-system-only solutions: collecting feedback in multicast applications. Our preliminary analysis of concasting effectiveness shows that it provides significant benefits, even with partial deployment. We argue that concast has the characteristics needed for a programmable service to be widely accepted and deployed in the Internet.

Concast is a scalable "inverse-multicast" network service: messages sent from multiple sources toward the same destination are merged into a single message that is delivered to the destination. The mapping from sent messages to received messages is programmable, so the service can be tailored to the needs of specific applications. However the service can also be used as a building block for other generic network services, such as a packet multiplexing service that encapsulates multiple small packets into a single larger packet and then unencapsulates the small packets at their (common) destination. Such a service offers several potential benefits, including reduced packet processing overhead and increased rate-sharing, but must also be carefully designed to avoid problems caused by added packet delays. We show how concast can serve as the basis for a multiplexing service that can be tailored to the needs of the application. We present simulation results showing that the benefits of our multiplexing service vary with delay. We also show that given certain queue-manipulation capabilities, benefits can be achieved with zero added delay.

Layered multicast is a promising technique for broadcasting adaptive-quality TV video to heterogeneous receivers. While several-layered multicast approaches have been proposed, prior work has identified several problems including significant and persistent instability in video quality, arbitrary unfairness with other sessions, low access link utilization due to conservative bandwidth allocation, and problems with receiver synchronization. In this paper we propose a new layered multicast scheme, where we exploit a simple, coarse-grained, two-tier loss differentiation architecture to achieve stable and fair bandwidth allocation for viewers. Despite the simplicity of our loss differentiation model, we show that it achieves most of the benefits of complex and costly priority dropping schemes. In addition, our protocol is receiver-driven and thus retains the incentives to limit bandwidth usage that are not present in existing priority dropping schemes.

This paper introduces concast, a new network service. Concast is the inverse of multicast: multiple sources send messages toward the same destination, which results in a single message being delivered to the destination. The received message appears to come from the concast group rather than any particular receiver. Different forms of concast service can be defined by varying the mapping from the set of sent messages to the received message. The service is useful for preventing implosion and reducing bandwidth consumption in cases where many senders transmit to the same receiver-for example in aggregating (or suppressing) positive (or negative) acknowledgements. We define the semantics of a simple concast service that is the inverse of multicast, as well as a more general custom concast, which allows users to define certain aspects of the service's semantics. We describe how to implement the service so that it scales approximately as well as IP multicast. We also present results from a simulation study showing that concast provides significant benefits in a layered-video application.

No abstract available.

No abstract available.

Efficient management of non-alphanumeric data (such as images, videos, and graphs) is essential to a large number of applications.This paper discusses the issues in pictorial information modeling, examines the suitability of traditional data modeling approaches, and then proposes a new objectoriented data modeling approach, called Modeling Object- Oriented Data Semantics (MOODS).A key idea in MOODS is to integrate the image processing component of an image information management system with the data modeling technique.In addition, a user may provide additional assistance in defining semantics at various stages.We argue that the data modeling technique must capture the sequence of transformations and allow a variety of semantics to be associated with the same data to accommodate different application domains.Additional salient features of MOODS include a notion of abstract function classes and dynamic binding of functions to data.

The use of long-haul networks by the scientific community to access resources at supercomputing centers has created a need for high-level user services and tools to provide transparent and efficient access to remote resources. A way to provide a computational service for supercomputer access in a distributed environment is described. The issues involved in the design of such a service are discussed, and attention is focused on a remote job submission facility. A prototype implementation is also described.>