A clustered enterprise Java distributed processing system is provided. The distributed processing system includes a first and a second computer coupled to a communication medium. The first computer includes a Java virtual machine (JVM) and kernel software layer for transferring messages, including a remote Java virtual machine (RJVM). The second computer includes a JVM and a kernel software layer having a RJVM. Messages are passed from a RJVM to the JVM in one computer to the JVM and RJVM in the second computer. Messages may be forwarded through an intermediate server or rerouted after a network reconfiguration. Each computer includes a Smart stub having a replica handler, including a load balancing software component and a failover software component. Each computer includes a duplicated service naming tree for storing a pool of Smart stubs at a node. The computers may be programmed in a stateless, stateless factory, or a stateful programming model. The clustered enterprise Java distributed processing system allows for enhanced scalability and fault tolerance.

Clustered enterprise JavaTM in a secure distributed processing system

Ordering and time are two different aspects of consistency of shared objects in a distributed system. One avoids conflicts between operations, the other addresses how quickly the effects of an operation are perceived by the rest of the system. Consistency models such as sequential consistency and causal consistency do not consider the particular time at which an operation is executed to establish a valid order among all the operations of a computation. Timed consistency models require that if a write operation is executed at time t, it must be visible to all nodes by time t +Δ. Timed consistency generalizes several existing consistency criteria and it is well suited for interactive and collaborative applications, where the action of one user must be seen by others in a timely fashion.

Timed consistency for shared distributed objects

This thesis concerns the issues involved in the development of virtual environments (VEs). VEs are more than virtual reality. We identify four main characteristics of them: graphical interaction, multimodality, interface agents, and multi-user. These characteristics are illustrated with an overview of different classes of VE-like applications, and a number of state-of-the-art VEs. To further define the topic of research, we propose a general framework for VE systems development, in which we identify five major classes of development tools: methodology, guidelines, design specification, analysis, and development environments. Of each, we give an overview of existing best practices.

Development and Specification of Virtual Environments

Resource borrowing is a common underlying approach in grid computing and thin-client computing. In both cases, external processes borrow resources that would otherwise be delivered to the interactive processes of end-users, creating contention that slows these processes and decreases the comfort of the end-users. How resource borrowing and user comfort are related is not well understood and thus resource borrowing tends to be extremely conservative. To address this lack of understanding, we have developed a sophisticated distributed application for directly measuring user comfort with the borrowing of CPU time, memory space, and disk bandwidth. Using this tool, we have conducted a controlled user study with qualitative and quantitative results that are of direct interest to the designers of grid and thin-client systems. We have found that resource borrowing can be quite aggressive without creating user discomfort, particularly in the case of memory and disk. We also describe an on-going Internet-wide study using our tool.

/pdf/measuring-and-understanding-user-comfort-with-resource-13yb6z31ml.pdf

Measuring and understanding user comfort with resource borrowing

As collaboration in virtual environments becomes more object-focused and closely coupled, the frequency of conflicts in accessing shared objects can increase. In addition, two kinds of concurrency control "surprises" become more disruptive to the collaboration. Undo surprises can occur when a previously visible change is undone because of an access conflict. Intention surprises can happen when a concurrent action by a remote session changes the structure of a shared object at the same perceived time as a local access of that object, such that the local user might not get what they expect because they have not had time to visually process the change. A hierarchy of three concurrency control mechanisms is presented in descending order of collaborative surprises, which allows the concurrency scheme to be tailored to the tolerance for such surprises. One mechanism is semioptimistic; the other two are pessimistic. Designed for peer-to-peer vitual environments in which several threads have access to the shared scene graph, these algorithms are straightforward and relatively simple. They can be implemented using C/C++ and Java, under Windows and Unix, on both desktop and immersive systems. In a series of usability experiments, the average performance of the most conservative concurrency control mechanism on a local LAN was found to be quite acceptable.

Concurrency control mechanisms for closely coupled collaboration in multithreaded peer-to-peer virtual environments

Interactive (or Synchronous) groupware is increasingly be ing deployed in widely distributed environments. Users of such applications are accustomed to direct manipulation in terfaces that require fast response time. The state that enables interaction among distributed users can be replicate d to provide acceptable response time in the presence of high communication latencies. We describe and evaluate design choices for protocols that maintain consistency of such sta te. In particular, we develop workloads which model user actions, identify the metrics important from a user's viewpoi nt, and do detailed simulations of a number of protocols to evaluate how effective they are in meeting user requirements.

Responsiveness and consistency tradeoffs in interactive groupware

The paper presents our state sharing support for building object oriented interactive groupware in wide area distributed environments. We motivate and present an asynchronous model for updating replicated state, which supports atomicity of updates across multiple shared objects. Coupled with our flexible marshalling framework, this model allows existing application data structure classes to be easily extended and made shareable. To solve the problem of replica consistency we use a novel combination of three mechanisms: (1) global locks, (2) detection of incorrect update ordering, and (3) cloning a subset of the shared objects and state reinitialization. Finally, to reduce network load due to fine grain user interaction, we provide a framework for application specified event batching called Late Event Modification.

Flexible batching and consistency mechanisms for building interactive groupware applications

‘Highly interactive’ applications enable human users to interact with the application using direct manipulation input devices like mice, joysticks, body-position sensors etc. A class of such applications, synchronous groupware, such as distributed virtual environments, collaborative design, and multi-player games, also permit distributed users to interact with each other at the same time. Another class is virtual reality, which can be single or multi-user. A common theme of these applications is the need to provide quick response time despite scarcity of resources. Consequently, to make application development easier, many systems have been proposed which manage these resources on behalf of the application. However, there are no workloads for realistic evaluation of such systems, to see if they provide appropriate responsiveness, and at what cost. This paper describes a general approach towards designing such workloads. In synchronous groupware, collaboration or competition between users is enabled by shared data that is read and written by the users. Therefore, this shared data is one of the resources that needs to be managed so as to provide appropriate responsiveness. By responsiveness we mean both the time taken to see the response of an action on the data by the same user (response time or RT), and the effect of that action seen by a different user (user to user time or UUT). Another important goal for designers of algorithms managing this shared data is to support ‘scaling’, i.e. the users could be widely distributed, and/or there could be a potentially large number of users. Providing appropriate RT and UUT is difficult when groupware is deployed in a wide-area distributed environment like the Internet, where high communication latencies are common. Direct manipulation user interfaces can require response times of about looms, for example, manipulating something by dragging the mouse. However, due to the fundamental limitation of the speed of light, the round-trip delay to the far side of the planet is at least 200ms. Various data management algorithms and systems have been developed that claim to satisfy the scale requirements of groupware, while providing appropriate responsiveness. They range from centralized data, to replicated data with various replica consistency algorithms [2].

Workload modeling for highly interactive applications

Many application domains have already demonstrated that they can benefit greatly if efficient access can be provided to shared information across widely distributed users. We use the generic term object to describe units of shared information which could include files, web pages or language defined objects. Future applications will require object sharing modes richer than simple browsing. For example, a collaboration system that allows users distributed world-wide (e.g., managers of a multinational company) to interact with each other must manipulate objects that are both read and updated at multiple locations.Several assumptions, which are natural in the context of large scale systems, can be made about scalable object sharing systems. First, such systems will consist of many server nodes that will act as the storehouses for shared objects. These servers will enable access to objects to a much larger number of client nodes. To avoid high latencies and communication costs, servers will store replicated copies of objects frequently accessed by clients in their vicinity. Furthermore, clients will cache objects to reduce access latency and frequency of communication with servers. Both replication at servers and caching at clients result in multiple copies of an object which introduces the problem of maintaining consistency among the copies.Many levels of consistency are possible and the choice of a particular consistency level has implications on the programming as well as performance of a distributed application. Although consistency requirements across copies of a single object are easily seen, such requirements can arise between copies of different but related objects. For example, assume that user 1 writes a memo object ol to produce version o1,1 and later generates its updated version ol,2. User 2 reads ol,2 and writes memo object o2 in response. If user 3 reads memo o2 and wants to read o1 to understand it, it must be provided ol,2 and not o1,1 which could have been cached by it due to a previous read. Thus, consistency requirements exist across copies of ol and o2 even when user 3 accesses them in a read-only mode.We first identify some requirements that must be met by scalable object sharing schemes. We present arguments to demonstrate that existing techniques cannot easily be adapted to meet these requirements. This is followed by an outline of our approach.

Scalable information sharing in large scale distributed systems

Handle everyday research tasks with reliable, citation-backed results

Your personal Research Agent to handle research tasks with citation-backed results

Popular Tasks used by Researchers

How can I help with your research?

Meet SciSpace

Get more enhanced response by uploading the PDFs you want me to reference.

No relevant PDFs in your library

SciSpace is the AI research assistant for academics. Run systematic literature reviews on 280M+ papers, and write papers with cited sources. Trusted by 1M+ students, PhDs & researchers.

SciSpace | AI for Research

Analyze PDFs

Code & Manuscripts

Funding & Grants

Literature & Patents

Medical & Clinical Data

Systematic Review

Visualize & Present

Web & Data

Build a Google Scholar-like website for your research.

Build a website

Create charts and images for your research

Create a Chart

Write a paper for submission to a journal

Draft a manuscript

Patent Search

Design eye-catching scientific posters in minutes.

Scientific Poster Generation

Systematic Literature Review

One task is running at the moment. Your messages will be shown right after.

Drag and drop or click here to browse

Loved by <highlight>1 million+</highlight> researchers

Extract a list of specific topics and their sources from unstructured text

Topics

Compare and analyze relevant papers that matches with your search

Papers

Get insights from PDFs and bookmarked papers from your library

My library

Recent searches

Try searching for:

Catch AI-generated content in scholarly and non-scholarly content

{ai} Detector

Ai Writer

Get PDF Summaries, highlighted text explanations 

Chat with PDF

Effortlessly create in-text citations and bibliographies in APA and 2,500 other formats

Citation generator

Get explanations, summaries, and answers on academic papers

Ease up your research workflow with {scispace}'s cohort of exciting AI tools

Elevate your academic writing skills and convey your ideas the way you want

Paraphraser

Explore our range of reading and writing tools

Your file is being prepared and should be ready in a few minutes. If it's a large file, it might take a bit longer. You can close this window, and we'll email you the file when it's done.

You have reached a maximum limit of <strong>{limit}</strong> columns in the table. Remove at least <strong>1</strong> column to add or create another one.

Sumeer Bhola

Author Tools

Chat about Author

Papers

Responsiveness and consistency tradeoffs in interactive groupware

Responsiveness and consistency tradeoffs in interactive groupware

Flexible batching and consistency mechanisms for building interactive groupware applications

Workload modeling for highly interactive applications

Scalable information sharing in large scale distributed systems