Diagnosing different retinal diseases from Spectral Domain Optical Coherence Tomography (SD-OCT) images is a challenging task. Different automated approaches such as image processing, machine learning and deep learning algorithms have been used for early detection and diagnosis of retinal diseases. Unfortunately, these are prone to error and computational inefficiency, which requires further intervention from human experts. In this paper, we propose a novel convolution neural network architecture to successfully distinguish between different degeneration of retinal layers and their underlying causes. The proposed novel architecture outperforms other classification models while addressing the issue of gradient explosion. Our approach reaches near perfect accuracy of 99.8% and 100% for two separately available Retinal SD-OCT data-set respectively. Additionally, our architecture predicts retinal diseases in real time while outperforming human diagnosticians.

A key requirement for a distributed collaborative application is that all participants see the same copy of a shared window-object at different points in time (WYSIWIS). This is needed to maintain a cohesive view of the problem. We recognize that user actions are generated based on their understanding of the context of the problem, where context is defined in terms global view of the shared window object. However, it is noted that, actions generated from different sites in response to the same context may not be compatible with each other since execution of one action may change the context in such a way that other actions become irrelevant. This notion of compatibility of action is the crucial distinguishing factor between a distributed collaborative system and other distributed systems where independent actions are generally serializable. We propose a general framework that uses the concept of temporal epoch to implement a state-machine model of collaboration. We also explore the idea of `contextual integrity' as a pre-requisite for perceptual consistency among users.

A real-time data collection system in sensor network settings requires dealing with failures in the network and in the external environment: such as data corruptions by malicious devices and message timeliness violations in the network. Functional replication is employed to deal with such failures, with voting among the replica devices to move a correct data to the end-user. The goal of our paper is to develop a voting system that dynamically adapts its internal mechanisms to deal with various types of failures. The paper presents the design issues, with considerations of protocol correctness and performance. A goal is to reduce the message overhead - and hence the power drain on wireless connected sensor devices.

In this paper, we study the impact of network-level message loss/delays on the performance experienced by the players in a real-time multi-player game. The study is conducted through the prism of consistency models of the game state (logically) shared among the players. We employ a weaker notion of consistency that encompasses: (i) the real-time persistence effects of player actions in the physical game world; and (ii) the state obsolescence caused by the loss/delay of player and game server messages in the network. Both (i) and (ii) impact the realism and cohesiveness of the game being played. The user-level performance measure, namely, the player-level lag, is studied for multi-player games under realistic settings of network communications and human participation. Towards this end, the paper formulated a formal model of multiplayer games and then studied the effects of network delays and human persistence on the player-level lags experienced. Sample games studied are the Soldier of Fortune and the RogueSpear. The methodology can be employed for studying the the effectiveness of human elements participating in the collaborative simulation of a physical world (such as war games).

This paper describes the engineering of replica voting protocols for energy-efficiency in data delivery. The protocols employ 2-phase voting among replica processes to move a correct data from the external environment to the end-user(s) in a secure real-time application setting. The replicas may be wireless computation nodes deployed in a power-constrained environment. The cross-layer optimization techniques is employed to reduce the amount of network message exchanges and device processing cycles expended for data delivery to the user. This optimization can in turn reduce the battery energy consumption of wireless devices that participate in the voting protocol. Cross-layer design of a replica-based voting protocol is considered for deployment over IEEE- 802.11 networks. Furthermore, though the paper focused on replica voting as the application, the optimization techniques are useful in other application domains

In a distributed embedded system, data items may be moved from one set of functional modules to another through a common buffer that is interposed between them over a network. Here, the computation modules disseminating data should agree on what data items are written into the remote buffer, to coordinate their actions on the external environment. Furthermore, a timely effect of these actions requires enforcing deadlines on the processing of data from the remote buffer. To meet these requirements, we provide a publish-subscribe style programming structure that enables a shared view of the processing on data in the buffer by various computation modules over prescribed time intervals. Our structure allows an explicit application-level control of the asynchrony and timing of information flow between various modules. Its use is illustrated with a case study of a target tracking application. In general, our programming structure can be useful in a variety of embedded software systems such as shared e-desks and collaborative Web services.

The multimedia information exchanges in distributed collaborative applications may be modeled, from communication system perspective, as the flow of media messages between user entities, to provide access to shared window objects on workstations. An example of shared window is a design document interactively reviewed by a team of engineers over a discussion session. A key requirement is that all users should see the same local copy of a shared window object at any given point in time (WYSIWIS), even though these users may reside in different workstations interconnected over a network. In this paper, we study the temporal ordering of real-time persistent messages as the basis for achieving WYSIWIS. The approach requires specifying the synchronization constraints on accessing shared window objects in the form of state-transition relations and timeliness needs when processing messages for object state updates. Non-conflicting actions can be processed in any sequence by user entities, thereby increasing overall system-level performance and user-level efficacy. The paper describes the salient features of our concurrency control model, and then identifies the basic protocol elements to realize the model. Applications are also described to demonstrate the viability of our approach.

In a distributed collaborative application, a key requirement is that all users see the same copy of a shared window object at any given point in time (WYSIWIS). In this paper, we study 'user-assisted causal ordering' of messages as the basis for achieving WYSIWIS. The approach requires specifying the synchronization constraints on accessing shared window objects in the form of an order in which messages need to be processed and object state updated. The specifications are made available to the window subsystem based on the user-level knowledge about the actions on objects and the current (shared) object state. In contrast with the current approaches employing transaction models, our approach allows flexibility in the programming of collaboration-style applications, and offers increased levels of concurrency.

In a distributed embedded system, one or more data items may be moved from one functional module to another through a common buffer that is interposed between them over a network. Here, the computation modules generating and/or disseminating data should agree on what data items are written into the remote buffer, to coordinate their actions on the external environment. Furthermore, a timely effect of these actions requires enforcing deadlines on the processing of data from the remote buffer. We encouch the functionalities of reaching agreement on the data processed through a shared buffer and meeting the time deadlines associated with this data in an abstract programming primitive: 'timed atomic write'. The primitive has a rich semantics in that it enables a consistent view of the processing on data in the buffer by various computation modules over prescribed time intervals. The primitive allows an explicit application-level control of the asynchrony and timing of information flow between various modules. The paper describes the structure and semantics of the 'atomic write' primitive, and illustrates its use in a 'sensor data fusion' application.

From a graph-theoretical perspective, the problem of constructing multicast distribution paths, modeled as 'Steiner trees', is NP-complete. So, many heuristics-based algorithms are available to generate near-optimal trees. Typically, an algorithm first assigns the edge costs for all links, and then examines various candidate paths for interconnecting a given set of nodes. This strategy does not work well for the evolving multimedia application configurations (such as audio-video and image distributions) where it is often necessary to construct multiple distribution paths, viz., one per media data stream. This is because the overlapping of multiple tree segments over a common link forces the link cost to change, based on the delay and bandwidth characteristics of data streams flowing over these segments. Accordingly, algorithms that hitherto have assumed non-varying link costs during various phases of a run now need to take into account the variability of link costs as candidate trees with different levels of path overlapping are examined in a given run. In other words, as an algorithm runs by examining various paths, the link costs change. The paper embarks on a study of heuristics-based algorithms to tackle this 'modified Steiner tree' problem. The algorithms allow more cost-efficient routing of data than feasible otherwise with a classical treatment of the 'Steiner tree' problem.