Showing papers in "Scalable Computing: Practice and Experience in 2006"

Expert Systems: Principles and Programming

Abstract: Expert Systems: Principles and Programming Joseph C. Giarratano and Gary D. Riley Fourth Edition, Course Technology, Boston, MA, 2004 856 pages, $131.95 Language: English ISBN: 0534384471 Expert systems is one of the most successful, practical, and recognizable subsets of classical Artificial Intelligence. The ability to supply decisions or descision-making support in a specific domain has seen a vast application of expert systems in various fields such as healthcare, military, business, accounting, production, video games, and human resources. The theoretical and practical knowledge of expert systems is indispensable for a computer science, management information science or software engineering student. In its fourth edition, Expert Systems: Principles and Programming, as the title suggests, aims to be used as a complete textbook on this topic. The authors are respected authorities on expert systems, and were involved in the development of the popular CLIPS expert system tool which is dealt with thoroughly in this book. The book itself is divided into two major sections: the first six chapters deal with the theory of expert systems, the rationale behind their historical development and the current state of research; the next six sections are an introduction to CLIPS and how to use it to develop practical applications. The clear division between theory and practice serves to guide the student in choosing specific topics throughout the book. Each chapter ends with a set of problems and a useful bibliography. Appendix G provides a comprehensive list of software resources and will prove to be a very valuable asset to the student interested in exploring the practical aspects of expert systems as well as those who will be developing commercial applications incorporating expert systems. The first six chapters provide an indepth intoduction to expert systems, and deal with the representation of knowledge and methods of inference and reasoning. Each of these topics are introduced from scratch—for example, when dealing with knowledge representation, logic is described from its very basics, starting from propositional logic. The chapters on reasoning under uncertainty and inexact reasoning are very well constructed and are the most attractive feature of the book for me. Topics such as fuzzy logic and Dempster-Shafer theory are explained in good detail along with their practical significance. There is an objective flow through the chapters which helps to tie in the concepts and give an understanding on the progress of topics. Also, the disadvantages and pitfalls behind expert systems in general, and specific topics are well documented. The second section focusing on the CLIPS expert system tool is meant to be an aid in understanding and reinforcing the concepts of the first section, but does not require a thorough reading of the latter. CLIPS, developed in part by the authors at NASA, has become quite popular as a tool for studying expert system in many university courses as well as being used in several commercial and industrial applications. The expert system programming in CLIPS does not require much experience with programming and can be picked up rapidly thanks to its simple syntax and the helpful examples in the book. A new feature of the fourth edition is the introduction of COOL, the CLIPS Object-Oriented Language, which allows expert systems programmers to develop their systems in an object-oriented environment. The section is supplemented by a CD containing Windows and MacOS executables for CLIPS and reference guides—all of which can be downloaded from the Internet as well. Although the CLIPS examples deal with some problems of uncertainty in reasoning, there is no mention of using fuzzy logic or Dempster-Shafer theory in a practical setting—a serious disadvantage to the effectiveness of the book, considering the availability of tools such as FuzzyClips. The book itself is expensive—on the wrong side of a hundred dollars, but that seems to be the trend for academic books these days and shouldn't be a deterrent to anyone interested in the subject considering it has become one of the standard textbooks on expert systems. Raheel Ahmad Department of Computer Science Southern Illinois University Carbondale, IL 62901, USA

Parallel Scientific Computation: A Structured Approach using BSP and MPI

Abstract: Parallel Scientific Computation: A Structured Approach using BSP and MPI Rob H. Bisseling Hardcover: 324 pages Oxford University Press, USA (May 6, 2004) Language: English ISBN: 0198529392 In spite of many efforts, no solid framework exists for developing parallel software that is portable and efficient across various parallel architectures. The lack of such framework is mostly due to the absence of a universal model of parallel computation, which can play a role similar to that which Von Neumann’s model plays for the sequential computing, and inhibit the diversity of the existing parallel architecture and parallel programming models. Bulk Synchronous Parallel (BSP) is a parallel computing model proposed by Valiant in 1989, which provides a useful and elegant theoretical framework for bridging the gap between parallel hardware and software. This model comprises a computer archicture (BSP computer), a class of algorithms (BSP algorithm), and a performance model (BSP cost function). The attraction of BSP model lays in its simplicity. A BSP computer consists of collection of processors, each with private memory, and a communication network. A BSP algorithm consists of a sequence of supersteps. A superstep contains either a number of computation steps or a number of communication steps, followed by global barrier synchronization. A BSP performance cost function is based on four parameters: number of processors (p), processor computing rate (r), the ratio between the computation time and communication time (g), and the synchronization cost (l). In Parallel Scientific Computation: A Structured Approach using BSP and MPI, Rob Bisseling provides a practical introduction to the area of numerical scientific computation by using BSPlib communication library in parallel algorithm design and parallel programming. Each chapter contains: an abstract; a brief discussion of sequential algorithm included to make the material self-contain; the design and analysis of a parallel algorithm; an annotated program text; illustrative experimental results of an implementation on a particular parallel computer; bibliographic notes; theoretical and practical exercises. The source files of the printed program texts, together with a set of test programs that demonstrate their use, form a package called BSPedupack, which is available at the official home page of the book. Researchers, students, and savvy professionals, schooled in hardware or software, will value Bisseling's self-study approach to parallel scientific programming. After all, this is the first textbook provides a comprehensive overview of the technical aspects of building parallel programs using BSP. The book opens with an overview of BSP model and BSPlib, which tell you how to get started with writing BSP programs, and how to benchmark your computer as a BSP computer. Chapter 2 on dense LU decomposition presents a regular computation with communication patterns that are common in matrix computations. Chapter 3 on the FFT also treats a regular computation but one with a more complex flow of data. Chapter 4 presents the multiplication of a sparse matrix and dense vector. Appendix C presents MPI programs in the order of the corresponding BSP programs appear in the main text. The book includes a reasonable amount of real world examples, which support the theoretical aspects of the discussions. It is easy to follow and includes logical and consistent exposition and clear descriptions of basic and advanced techniques. Being a textbook, it contains various exercises and project assignments at the end of each chapter. However, sample solutions for these exercises are still not available. Perhaps an accompanying CD carrying the sample solutions and tutorials for use in the classroom would have added to the academic value of the book. However, the bibliographic notes given at the ends of each chapter, as well as the references at the end of the book, are quite useful for those interested in exploring the subject of BSP development further. The book is contemporary, well presented, and balanced between concepts and the technical depth required for developing parallel algorithms. Although the book takes a simple performance view of parallel algorithms design, readers should have some basic knowledge of parallel computing, data structures, and C programming. Overall, the book is suitable as a textbook for one-term undergraduate or graduate courses, as a self-study book, or as technical training material for professionals. Ami Marowka Department of Software Engineering Shenkar College of Engineering and Design Ramat-Gan, Israel.

A WS -Agreement Based Resource Negotiation Framework for Mobile Agents

Abstract: Mobile agents require access to computing resources on heterogeneous systems across the Internet. They need to be able to negotiate their requirements with the systems on which they wish to be hosted. This paper presents a negotiation infrastructure with which agents acquire time-limited resource contracts through negotiation with one or more mediators instead of individual hosting systems. Mediators represent groups of autonomous hosts. The negotiation protocol and language are based on the WS-Agreement Specification, and have been implemented and tested within the AgentScape framework.

Generative Mobile Agent Migration in Heterogeneous Environments

Abstract: Agent migration, in theory, makes it possible to bring computations to the resources required In practice, however, homogeneity in programming language and/or agent platform is required This paper presents an approach that supports heterogeneous agents and platforms: agents written in different languages can migrate between non-identical platforms Instead of migrating the code (including data and state) of an agent, a blueprint of an agent's functionality is transferred (together with its state) An agent factory on the receiving platform generates new code on the basis of this blueprint This approach of generative mobility not only has implications for interoperability but also for security, as discussed in this paper

Mobility in Distributed Systems

Abstract: Mobile agents are programs with the additional capability to move between computers across a network connection. Movement implies that the running program that constitutes an agent moves from one system to another, taking with the agent the code that constitutes the agent as well as the state information of the agent. The movement of agents may be user-directed or self-directed (i.e. autonomous). In the case of user-directed movement, agents are configured with an itinerary that dictates the movement of the agents. In the case of self-directed movement, agents may move in order to better optimize their operation. Mobility may also be a combination of user- and self-directedness. Mobile agents provide three basic capabilities: mobile code, mobile computation, and mobile state. These three capabilities are shown in the figure below. Each of the capabilities is an evolution of previously well-established notions in distributed and networked systems. Mobile computation involves moving a computation from one system to another. This capability is an evolution of remote computation, which allows a system to tap into the computational resources of another system over a network connection. One of the original mechanisms for remote computation was Remote Procedure Call (RPC). Java Remote Method Invocation (RMI) is another example of remote computation as are servlets and stored procedures. The difference between mobile and remote computation is that mobile computation supports network disconnection. In a traditional remote computation model, the system requesting the service (the client) must remain connected to the system providing the service (the server) for the duration of the remote computation operation. Additionally, depending on the interface exposed by the server, an interaction can require an arbitrary number of messages between client and server. If network connectivity is lost, the remote computation will become an orphaned computation that will either be terminated or whose results will be discarded. A mobile computation, on the other hand, is an autonomous entity. Once the computation moves from the first system (which may nominally be called the client) to the second system (the server), the computation continues to execute on the server even if the client becomes disconnected. The agent returns to the client with the results of the computation when (and if) the connectivity is recovered. Mobile Code is the ability to move code from one system to another. The code may be either source code that is compiled or interpreted or binary code. Binary code may further be either machine dependent or be some intermediate, machine-independent form. Mobile code is used in other contexts besides mobile agents. For example, system administrators use mobile code in order to remotely install or upgrade software on client systems. Similarly, a web browser uses mobile code to pull an applet or script to execute as part of a web page. Code may be mobile in two different ways: push and pull. In the push model, the system sending the code originates the code transfer operation whereas in the pull model, the system receiving the code originates the code transfer operation. An example of the pull model is a Web browser downloading components such as applets or scripts. Remote installation is an example of the push model. Mobile agent systems use the push model of code mobility. Pull mobility is often considered to be more secure and trustworthy because the host receiving the code is the one that requested the code. Usually, the origin of the request lies in some action carried out by a user of the system and hence pull mobility is superficially more secure. Push mobility on the other hand allows a system to send code to the receiving system at unexpected or unmonitored times. Hence push mobility is less trustworthy from a user’s point of view. In practice the overwhelming majority of security exploits encountered in distributed systems originates in careless user actions such as running mail attachments. Mobile code allows systems to be extremely flexible. New capabilities can be downloaded to systems on the fly thereby dynamically adding features or upgrading existing features. Moreover, if capabilities can be downloaded on demand, temporarily unused capabilities can also be discarded. Swapping capabilities on an as-needed basis allows systems to support small memory constrained devices. Discarding capabilities after use can also help improve system security. Mobile state is an evolution of state capture, which allows the execution state of a process to be captured. State capture has been traditionally used for checkpointing systems to protect against unexpected system failure. In the event of a failure, the execution of a process can be restarted from the last checkpointed state thereby not wasting time by starting from the very beginning. Checkpointing is thus very useful for long-running processes. Operating system research has investigate capturing entire process states, a variant of checkpointing, for load balancing purposes in the early 1980s, but that avenue of research proved to be a dead-end due to coarse granularity of process and semantics problem due to the impossibility of capturing operating system resources such as open file descriptors. Mobile state allows the movement of the execution state of an agent to another system for continued execution. The key advantage provided by mobile state is that the execution of the agent does not need to restart after the agent moves to a new host. Instead, the execution continues at the very next instruction in the agent. Not all mobile agent systems provide support for state mobility. The term strong mobility is used to describe systems that can capture and move execution state with the agent. Operationally, strong mobility guarantees that all variables will have identical values and the program counter will be at the same position. Weakly mobile-agent systems, on the other hand, usually support the capture of most of a program’s data, but restart the program from a predefined program point and thus require some programmer involvement at each migration. The advantage of strong mobility is that the result of migrating is well defined and easier to understand, but its disadvantage is that it is much more complex to implement efficiently. The most important advantage provided by strong mobility is the ability to support external asynchronous migration requests (also known as forced mobility). This allows entities other than the agent (such as other system components, an administrator, or the owner) to request that an agent be moved. Forced mobility is useful for survivability, load-balancing, forced isolation, and replication for fault-tolerance, and is an important aspect of the agile computing approach. For some applications, the technical issues of software mobility are dwarfed by security issues. Despite fits and starts, mobile agents herald emerging technological solutions. This special issue provides a good sampling of this frontier. It is our hope and desire that the software industry embrace the capabilities offered by mobile agents. In the future, we hope to see general purpose programming languages that support mobility as well as large scale development platforms and toolkits. Niranjan Suri Institute of Human and Machine Cognition Henry Hexmoor Sourthern Illinois University

Software Agent Technology

Abstract: Software agent technology is an exciting paradigm which can be efficiently applied to many distributed computing problems, particularly those that require dynamic behavior to reach a solution. Software agent technology has emerged as an enhancement of, if not an alternative to, the traditional client/server model in such an environment. Mobile agents can migrate to a desired remote peer and take advantage of local processing rather then relying on remote procedure calls (RPC) across the network, as in the case of client/server systems. Also, agents are entities which function continuously and autonomously in a particular environment, and are able to carry out activities in a flexible and intelligent manner that is responsive to the dynamically changing environment. Ideally, an agent that functions continuously would be able to learn from experience and have capabilities to adapt to ad-hoc events and apply suitable functionality depending on the circumstances. Employment of the agent technology in the traditional client-server environments could result in more robust, flexible and better performing solutions for many applications. In this special issue, we have collected five cutting edge research papers which are the extended versions of a selected group of the papers already published in Intelligent Agent Systems 2005 (IAS 05) special track at the 18th International FLAIRS Conference. The first paper, Agents Go Traveling, by D. O'Kane, D. Marsh, S. Shen, R. Tynan and G. M. P. O'Hare, is concerned with the infrastructure support for nomadic agents. The authors have introduced the Agent Travel Metaphor (ATM) which offers a metaphor fostering integration of control and security. The second paper is entitled Exploiting Shared Ontologies with Default Information for Web Agents, by Y. Ma, B. Jin and M. Zhou. This paper uses distributed description logic (DDL) to model the mappings between ontologies used by different agents and further makes an extension to the DDL model. A WS-Agreement Based Resource Negotiation Framework for Mobile Agents is the title of the third paper by D. G. A. Mobach, B. J. Overeinder, and F. M. T Brazier. This paper presents a negotiation infrastructure with which agents acquire time-limited resource contracts through negotiation with one or more mediators instead of individual hosting systems. The fourth paper, Agent Composition via Role-Based Infrastructures, by G. Cabri, proposes to build infrastructures based on roles, which are abstractions that enable the composition of different agents in an open scenario. Finally the last paper, unlike the first four papers, presents an application of software agents for support of student mobility. This paper is authored by M. Ganzha, W. Kuranowski and M. Paprzycki. We have tried our best to present quality works in this special issue and certainly hope that we have achieved this goal. Shahram Rahimi, Raheel Ahmad

Mathematical service discovery: architecture, implementation and performance

Abstract: Service discovery and matchmaking in a distributed environment has been an active research issue since at least the mid 1990s Previous work on matchmaking has typically presented the problem and service descriptions as free or structured (marked-up) text, so that keyword searches, tree-matching or simple constraint solving are sufficient to identify matches. In this paper, we discuss the problem of matchmaking for mathematical services, where the semantics play a critical role in determining the applicability or otherwise of a service. A matchmaking architecture supporting the use of match plug-ins is first described, followed by the types of plug-ins that can be supported. The matched services are ranked based on the score obtained from each plug-in, with the user being able to decide which plug-in is most significant in the context of their particular application. We consider the effect of pre- and post-conditions of mathematical service descriptions on matching, and how and why to reduce queries into DNF and CNF before matching. Application examples demonstrate in detail how the matching process works for all four algorithms. Additionally, an evaluation of the ontological mode is provided, regarding performance of loading ontologies, query response time and the overall scalability is conducted. The performance results are used to demonstrate scalability issues in supporting ontology-based discovery within a Web Services environment.

Agent Composition via Role-based Infrastructures

Abstract: Software agents represent an interesting paradigm to approach complex and distributed systems. Their sociality enables to build multiagent systems, where different agents interact to pursue their goals. Multiagent systems can involve both cooperative and competitive agents. In both cases, the composition of different agents is an issue that must be faced by developers. In this paper, we propose to build infrastructures based on roles, which are abstractions that enable the composition of different agents in an open scenario. Some concrete examples are provided to support our proposal.

The Great Plains Network (GPN) Middleware Test Bed

Abstract: GPN (Great Plains Network) is a consortium of public universities in seven mid-western states. GPN goals include regional strategic planning and the development of a collaboration environment, middleware services and a regional grid for sharing computational, storage and data resources. A major challenge is to arrive at a common authentication and authorization service, based on the set of heterogeneous identity providers at each institution. GPN has built a prototype middleware test bed that includes Shibboleth and other NMI-EDIT middleware components. The test bed includes several prototype end-user applications, and is being used to further our research into fine-grained access control for virtual organizations. The GPN prototype applications and namespace form a basis for the design and deployment of a robust and scalable attribute management architecture.

Software agents in support of student mobility

Abstract: Autonomous software agents are often claimed to become a new generation of tools facilitating efficient management of information. While a number of possible agent application areas can be found in the literature, support for academic mobility is not one of them. At the same time student mobility is one of the important objectives within the European Union and, as we argue in this paper, software agents could be used to streamline administrative processes involved in setting up student participation and help students that are interested in it as well as administrative units that have to support it. In this paper we introduce an agent system designed to facilitate student mobility, present UML diagrams of agents of that system and discuss an initial implementation of a system-skeleton.

WebCom-G and MPICH-G2 Jobs

Abstract: This paper discusses using WebCom-G to handle the management & scheduling of MPICH-G2 (MPI) jobs. Users can submit their MPI applications to a WebCom-G portal via a web interface. WebCom-G will then select the machines to execute the application on, depending on the machines available to it and the number of machines requested by the user. WebCom-G automatically & dynamically constructs a RSL script with the selected machines and schedules the job for execution on these machines. Once the MPI application has finished executing, results are stored on the portal server, where the user can collect them. A main advantage of this system is fault survival, if any of the machines fail during the execution of a job, WebCom-G can automatically handle such failures. Following a machine failure, WebCom-G can create a new RSL script with the failed machines removed, incorporate new machines (if they are available) to replace the failed ones and re-launch the job without any intervention from the user. The probability of failures in a Grid environment is high, so fault survival becomes an important issue.

Agents Go Traveling

Abstract: This paper is concerned with infrastructural support for nomadic agents. Agent migration provides a wide range of advantages and benefits to system designers, however issues relating to security and integrity mobile agents has mitigated against the harvesting of their true potential. Within this paper we introduce the Agent Travel Metaphor (ATM) which offers a comprehensive metaphor fostering integrating of control and security for mobile agents. We describe the metaphor together with its incorporation within the Agent Factory multi-agent system.