David W. Levine

Itinerant agents for mobile computing

Describes a framework for itinerant agents that can be used to implement secure, remote applications in large, public networks such as the Internet or the IBM Global Network. Itinerant agents are programs, dispatched from a source computer, that roam among a set of networked servers until they accomplish their task. This is an extension to the client/server model in which the client sends a portion of itself to the server for execution. An additional feature of itinerant agents is their ability to migrate from server to server, perhaps seeking one that can help with the users task or perhaps collecting information from all of them. A major focus of the article is the agent meeting point, an abstraction that supports the interaction of agents with each other and server based resources The article begins with an overview of the operation of an itinerant agent framework and a review of previous work. The authors consider likely applications of itinerant agents and discuss one specific example in detail. They give an architectural description of the structure of itinerant agents, the languages employed to create them, and the execution environments required at the servers; and also a detailed description of how an itinerant agent is processed at a server. Security issues are then discussed and finally they consider the technical advantages of the itinerant agent framework and the services it enables. >

Winner determination in combinatorial auction generalizations

Combinatorial markets where bids can be submitted on bundles of items can be economically desirable coordination mechanisms in multiagent systems where the items exhibit complementarity and substitutability. There has been a surge of research on winner determination in combinatorial auctions. In this paper we study a wider range of combinatorial market designs: auctions, reverse auctions, and exchanges, with one or multiple units of each item, with and without free disposal. We first theoretically characterize the complexity of finding a feasible, approximate, or optimal solution. Reverse auctions with free disposal can be approximated (even in the multi-unit case), although auctions cannot. When XOR-constraints between bids are allowed (to express substitutability), the hardness turns the other way around: even finding a feasible solution for a reverse auction or exchanges is &Ngr;&Pgr;-complete, while in auctions that is trivial. Finally, in all of the cases without free disposal, even finding a feasible solution is &Ngr;&Pgr;-complete.We then ran experiments on known benchmarks as well as ones which we introduced, to study the complexity of the market variants in practice. Cases with free disposal tended to be easier than ones without. On many distributions, reverse auctions with free disposal were easier than auctions with free disposal---as the approximability would suggest---but interestingly, on one of the most realistic distributions they were harder. Single-unit exchanges were easy, but multi-unit exchanges were extremely hard.

Dynamics of an Information-Filtering Economy

Our overall goal is to characterize and understand the dynamic behavior of information economies: very large open economies of automated information agents that are likely to come into existence on the Internet. Here we model a simple information-filtering economy in which broker agents sell selected articles to a subscribed set of consumers. Analysis and simulation of this model reveal the existence of both desirable and undesirable phenomena, and give some insight into their nature and the conditions under which they occur. In particular, efficient self-organization of the broker population into specialized niches can occur when communication and processing costs are neither too high nor too low, but endless price wars can undermine this desirable state of affairs.

VWRAP for virtual worlds interoperability [Standards]

The IETF has chartered a Virtual World Region Agent Protocol Working Group (VWRAP WG). This article briefly describes the history of virtual worlds, the architecture, protocols, and operation of Second Life (a currently prominent virtual world), and the emergence of standards efforts within the virtual world space. The authors detail the current efforts and timeline of the VWRAP WG.

CONNECT: a personal remote messaging and monitoring system to aid people with disabilities

In this article we introduce CONNECT, an infrastructure running on small wireless devices (e.g., PDA phones) and servers that aids people with disabilities in leading their everyday lives. We refer to the target (client) devices as personal portable devices (PPDs). The architecture of the CONNECT system is described, with emphasis on the accessibility services provided to its clients. As an example, the reminder service of CONNECT is profiled where care providers and community organizers (or general users who have appropriate rights) can send timely reminders to the PPD owners, giving them a chance to respond to these messages. In conjunction with the connect project, 600 PPDs are deployed to people with disabilities for evaluation purposes.

On Implementing a Protocol Independent MIB

The Management Information Base (MIB) plays a key role in a network management system (figure 1) simply because: first, network management applications need structured information about the managed network; second, the network itself usually does not provide a simple and structured interface for information services. Currently, when network management applications are developed, they are designed to work with either Simple Network Management Protocol (SNMP) [6, 5] or Common Management Information Protocol (CMIP) [2], But, since a management information base (MIB) is only a repository of information about various network devices, the design of a MIB should not be constrained by the question, “what is the query access protocol.” Instead, our major concerns in building a MIB should be the data model and the structure it imposes on network information. These concerns can be addressed in a manner which is protocol independent.

Creating portable and automatically scalable parallel software using the PARSA/spl trade/ programming methodology

We present a programming methodology that reduces parallel programming complexity, while creating portable and automatically scalable parallel software. To support this methodology two separate tools have been developed - the PARSA software development environment, and an accompanying thread manager. The development environment addresses programming issues via an object-based graphical programming methodology that transforms a project automatically into a portable and scalable source code. The generated source code makes calls to the user-level thread manager, which manages the run time execution of the parallel software. Two sample applications that contain various forms of parallelism have been developed and are compiled on three different systems with diverse native threading mechanisms to demonstrate portability. Finally, the automatic scalability is demonstrated with the run time performance of the applications on multiprocessor systems.

A tool based methodology for development of automatically scalable and reusable parallel code

Program performance may be improved by efficiently programming some key sections of the software. We present a methodology for converting selected portions of source code into automatically scalable multithreaded routines, without forcing programmers to concentrate on parallel programming issues. These developed routines can be reused across various projects, operating systems and system architectures. To support this methodology two separate but tightly coupled tools have been developed -PARSA/sup (TM)/ software development environment (SDE) and the ThreadMan/sup (TM)/ thread manager. The SDE addresses programming issues by allowing a graphical object based approach to develop multithreaded routines that abstracts the users from parallel programming. ThreadMan manages the software developed using SDE. ThreadMan is a user-level thread manager that automatically spawns and schedules threads at runtime. Two examples have been developed using this methodology to demonstrate that there is virtually no degradation in performance when compared to sequential code, in a single processor system and scalability is achieved as the number of processors is increased.