Showing papers on "State (computer science) published in 2011"

Programming wireless sensor networks: Fundamental concepts and state of the art

Abstract: Wireless sensor networks (WSNs) are attracting great interest in a number of application domains concerned with monitoring and control of physical phenomena, as they enable dense and untethered deployments at low cost and with unprecedented flexibility. However, application development is still one of the main hurdles to a wide adoption of WSN technology. In current real-world WSN deployments, programming is typically carried out very close to the operating system, therefore requiring the programmer to focus on low-level system issues. This not only distracts the programmer from the application logic, but also requires a technical background rarely found among application domain experts. The need for appropriate high-level programming abstractions, capable of simplifying the programming chore without sacrificing efficiency, has long been recognized, and several solutions have hitherto been proposed, which differ along many dimensions. In this article, we survey the state of the art in programming approaches for WSNs. We begin by presenting a taxonomy of WSN applications, to identify the fundamental requirements programming platforms must deal with. Then, we introduce a taxonomy of WSN programming approaches that captures the fundamental differences among existing solutions, and constitutes the core contribution of this article. Our presentation style relies on concrete examples and code snippets taken from programming platforms representative of the taxonomy dimensions being discussed. We use the taxonomy to provide an exhaustive classification of existing approaches. Moreover, we also map existing approaches back to the application requirements, therefore providing not only a complete view of the state of the art, but also useful insights for selecting the programming abstraction most appropriate to the application at hand.

Input to locked computing device

Abstract: A method comprises: receiving, at a computing device 102 that is in a locked state, one or more user inputs 110 to unlock the device and to execute at least one command that is different from a command for unlocking the device; executing in response to the user inputs to unlock the device an unlocking operation 114 to convert the device from a locked state to an unlocked state; and executing the at least one command 112 in response to receiving the user inputs to execute the at least one command, so that its results 116 are first displayed on the device to a user automatically after the device changes from the locked state to the unlocked state. A system can thus perform in parallel an unlocking operation and a user-requested operation; for example, a user can simultaneously perform an action, instigated by a touch or voice input, and unlock the device. Multiple actions (354 in Figure 3B) may be available at the same time.

All-photonic multifunctional molecular logic device.

Abstract: Photochromes are photoswitchable, bistable chromophores which, like transistors, can implement binary logic operations. When several photochromes are combined in one molecule, interactions between them such as energy and electron transfer allow design of simple Boolean logic gates and more complex logic devices with all-photonic inputs and outputs. Selective isomerization of individual photochromes can be achieved using light of different wavelengths, and logic outputs can employ absorption and emission properties at different wavelengths, thus allowing a single molecular species to perform several different functions, even simultaneously. Here, we report a molecule consisting of three linked photochromes that can be configured as AND, XOR, INH, half-adder, half-subtractor, multiplexer, demultiplexer, encoder, decoder, keypad lock, and logically reversible transfer gate logic devices, all with a common initial state. The system demonstrates the advantages of light-responsive molecules as multifunctional, reconfigurable nanoscale logic devices that represent an approach to true molecular information processing units.

Model Checking and the State Explosion Problem

Abstract: Model checking is an automatic verification technique for hardware and software systems that are finite state or have finite state abstractions. It has been used successfully to verify computer hardware, and it is beginning to be used to verify computer software as well. As the number of state variables in the system increases, the size of the system state space grows exponentially. This is called the “state explosion problem”. Much of the research in model checking over the past 30 years has involved developing techniques for dealing with this problem. In these lecture notes, we will explain how the basic model checking algorithms work and describe some recent approaches to the state explosion problem, with an emphasis on Bounded Model Checking.

Method and apparatus for managing an energy consuming load

Abstract: A method for managing an energy consuming load in a group of energy consuming loads and a method for managing the group of energy consuming loads. The method includes generating sets of load state data from the loads, making enablement state decisions for one or more loads using the sets of load state data, and implementing the enablement state decisions. Each of the enablement state decisions reflects an enablement state of a load, wherein the enablement state is either a load enabled state where the load is capable of operating even when the load is not actually operating or a load disabled state where the load is not capable of operating. A computer readable medium may include computer readable instructions for directing a processor to perform the methods and make the enablement state decision. Further, an apparatus comprised of a processor may be programmed to perform the methods.

Interface with Gaze Detection and Voice Input

Abstract: Methods, computer programs, and systems for interfacing a user with a computer program, utilizing gaze detection and voice recognition, are provided. One method includes an operation for determining if a gaze of a user is directed towards a target associated with the computer program. The computer program is set to operate in a first state when the gaze is determined to be on the target, and set to operate in a second state when the gaze is determined to be away from the target. When operating in the first state, the computer program processes voice commands from the user, and, when operating in the second state, the computer program omits processing of voice commands.

Orleans: cloud computing for everyone

Abstract: Cloud computing is a new computing paradigm, combining diverse client devices -- PCs, smartphones, sensors, single-function, and embedded -- with computation and data storage in the cloud. As with every advance in computing, programming is a fundamental challenge, as the cloud is a concurrent, distributed system running on unreliable hardware and networks. Orleans is a software framework for building reliable, scalable, and elastic cloud applications. Its programming model encourages the use of simple concurrency patterns that are easy to understand and employ correctly. It is based on distributed actor-like components called grains, which are isolated units of state and computation that communicate through asynchronous messages. Within a grain, promises are the mechanism for managing both asynchronous messages and local task-based concurrency. Isolated state and a constrained execution model allow Orleans to persist, migrate, replicate, and reconcile grain state. In addition, Orleans provides lightweight transactions that support a consistent view of state and provide a foundation for automatic error handling and failure recovery. We implemented several applications in Orleans, varying from a messaging-intensive social networking application to a data- and compute-intensive linear algebra computation. The programming model is a general one, as Orleans allows the communications to evolve dynamically at runtime. Orleans enables a developer to concentrate on application logic, while the Orleans runtime provides scalability, availability, and reliability.

Memristor-based IMPLY logic design procedure

Abstract: Memristors can be used as logic gates. No design methodology exists, however, for memristor-based combinatorial logic. In this paper, the design and behavior of a memristive-based logic gate - an IMPLY gate - are presented and design issues such as the tradeoff between speed (fast write times) and correct logic behavior are described, as part of an overall design methodology. A memristor model is described for determining the write time and state drift. It is shown that the widely used memristor model - a linear ion drift memristor - is impractical for characterizing an IMPLY logic gate, and a different memristor model is necessary such as a memristor with a current threshold.

Correct, Reactive, High-Level Robot Control

Abstract: In this article, we presented an overview of how temporal logic synthesis, coupled with abstractions and continuous bisimilar controllers, can be used to generate high-level, reactive robot control. We illustrated the ideas using the DUC mission, and we presented two approaches to deal with the inherent state explosion problem.

Bootstrapping Trust in Modern Computers

Abstract: Trusting a computer for a security-sensitive task (such as checking email or banking online) requires the user to know something about the computer's state. We examine research on securely capturing a computer's state, and consider the utility of this information both for improving security on the local computer (e.g., to convince the user that her computer is not infected with malware) and for communicating a remote computer's state (e.g., to enable the user to check that a web server will adequately protect her data). Although the recent "Trusted Computing" initiative has drawn both positive and negative attention to this area, we consider the older and broader topic of bootstrapping trust in a computer. We cover issues ranging from the wide collection of secure hardware that can serve as a foundation for trust, to the usability issues that arise when trying to convey computer state information to humans. This approach unifies disparate research efforts and highlights opportunities for additional work that can guide real-world improvements in computer security.

Stateful applications operating in a stateless cloud computing environment

Abstract: A cloud computing environment may use a virtualization layer within a stateless cloud computing process to capture, store, and retrieve state information generated by a stateful application executing within the process. The virtualization layer may monitor various state storage systems to identify changes to stateful items and store the stateful items in a state storage mechanism. The virtualization layer may intercept and redirect calls to the stateful items stored in the state storage mechanism. A cloud computing manager may start and stop the stateless cloud computing process, and may recover the state and resume executing the application.

Amortised Resource Analysis with Separation Logic

Abstract: Type-based amortised resource analysis following Hofmann and Jost---where resources are associated with individual elements of data structures and doled out to the programmer under a linear typing discipline---have been successful in providing concrete resource bounds for functional programs, with good support for inference In this work we translate the idea of amortised resource analysis to imperative pointer-manipulating languages by embedding a logic of resources, based on the affine intuitionistic Logic of Bunched Implications, within Separation Logic The Separation Logic component allows us to assert the presence and shape of mutable data structures on the heap, while the resource component allows us to state the consumable resources associated with each member of the structure We present the logic on a small imperative language, based on Java bytecode, with procedures and mutable heap We have formalised the logic and its soundness property within the Coq proof assistant and extracted a certified verification condition generator We also describe an proof search procedure that allows generated verification conditions to be discharged while using linear programming to infer consumable resource annotations We demonstrate the logic on some examples, including proving the termination of in-place list reversal on lists with cyclic tails

Optimizing data partitioning for data-parallel computing

Abstract: Performance of data-parallel computing (e.g., MapReduce, DryadLINQ) heavily depends on its data partitions. Solutions implemented by the current state of the art systems are far from optimal. Techniques proposed by the database community to find optimal data partitions are not directly applicable when complex user-defined functions and data models are involved. We outline our solution, which draws expertise from various fields such as programming languages and optimization, and present our preliminary results.

Method and apparatus for estimating the state of a system

Abstract: Disclosed herein are methods, apparatuses, and techniques for estimating the state of a system. According to one implementation, a Massively Parallel Nested Factorisation technique, or MPNF, is disclosed that runs efficiently on parallel computer architectures. Also disclosed is a procedure used to create and utilize MPNF ordering.

Data writing method, memory controller, and memory storage apparatus

Abstract: A method for writing updated data into a flash memory module having a plurality of physical pages is provided, wherein each physical page is the smallest writing unit of the flash memory module. The method includes partitioning a physical page into storage segments and configuring a state mark for each storage segment, wherein the state marks indicate the validity of data stored in the storage segments. The method also includes writing the updated data into at least one of the storage segments and changing the state mark corresponding to the storage segment containing the updated data, wherein the state mark corresponding to the storage segment containing the updated data indicates a valid state, and the state marks corresponding to the other storage segments of the physical page not containing the updated data indicate an invalid state. Thereby, the time for writing data into a physical page is effectively shortened.

Formal Analysis of Protocols Based on TPM State Registers

Abstract: We present a Horn-clause-based framework for analysing security protocols that use \emph{platform configuration registers} (PCRs), which are registers for maintaining state inside the Trusted Platform Module (TPM). In our model, the PCR state space is unbounded, and our experience shows that a na\"\i ve analysis using ProVerif or SPASS does not terminate. To address this, we extract a set of instances of the Horn clauses of our model, for which ProVerif does terminate on our examples. We prove the soundness of this extraction process: no attacks are lost, that is, any query derivable in the more general set of clauses is also derivable from the extracted instances. The effectiveness of our framework is demonstrated in two case studies: a simplified version of Microsoft Bit locker, and a digital envelope protocol that allows a user to choose whether to perform a decryption, or to verifiably renounce the ability to perform the decryption.

Program Mode Transition

Abstract: A computing system is configured to execute a computer program on a server and to provide a video stream of the program output to a geographically remote client over a communication network. The computing system is further configured to provide executable content of the computer program to the client over the communication network in parallel with the video stream. When a sufficient amount of the executable content has been provided to the client execution of the computer program is transitioned from the server to the client. The transition optionally includes communicating a state of the computer program from the server to the client. The executable content can be provided to the client in an order that is determined based on the state of the computer program. Those parts of the executable content deemed most likely to be necessary to support game play on the client are given priority.

Information-driven interaction-oriented programming: BSPL, the blindingly simple protocol language

Abstract: We present a novel approach to interaction-oriented programming based on declaratively representing communication protocols. Our approach exhibits the following distinguishing features. First, it treats a protocol as an engineering abstraction in its own right. Second, it models a protocol in terms of the information that the protocol needs to proceed (so agents enact it properly) and the information the protocol would produce (when it is enacted). Third, it naturally maps traditional operational constraints to the information needs of protocols, thereby obtaining the desired interactions without additional effort or reasoning. Fourth, our approach naturally supports shared nothing enactments: everything of relevance is included in the communications and no separate global state need be maintained. Fifth, our approach accommodates, but does not require, formal representations of the meanings of the protocols. We evaluate this approach via examples from the literature.

BLOCK: a black-box approach for detection of state violation attacks towards web applications

Abstract: State violation attacks towards web applications exploit logic flaws and allow restrictive functions and sensitive information to be accessed at inappropriate states. Since application logic flaws are specific to the intended functionality of a particular web application, it is difficult to develop a general approach that addresses state violation attacks. To date, existing approaches all require web application source code for analysis or instrumentation in order to detect state violations. In this paper, we present BLOCK, a BLack-bOx approach for detecting state violation attaCKs. We regard the web application as a stateless system and infer the intended web application behavior model by observing the interactions between the clients and the web application. We extract a set of invariants from the web request/response sequences and their associated session variable values during its attack-free execution. The set of invariants is then used for evaluating web requests and responses at runtime. Any web request or response that violates the associated invariants is identified as a potential state violation attack. We develop a system prototype based on the WebScarab proxy and evaluate our detection system using a set of real-world web applications. The experiment results demonstrate that our approach is effective at detecting state violation attacks and incurs acceptable performance overhead. Our approach is valuable in that it is independent of the web application source code and can easily scale up.

Computer, communication device, and communication control system

Abstract: A physical server monitors a state of a virtual machine that runs on the server. When it is detected that the state of the virtual machine is changed, the physical server transmits information indicating the state change of the virtual machine to a physical switch accommodating the server and controlling communication between the server or the virtual machine and another device or another virtual machine. The physical switch stores configuration information of the virtual machine that runs on an information processing device accommodated by the server. When the physical switch receives the information indicating the state change of the virtual machine from the physical server, the physical switch updates the configuration information based on the received information. The physical switch controls the communication between the physical server or the virtual machine and another device or another virtual machine, based on the stored configuration information.

State control of remote hosts for management of distributed applications

Abstract: Configuring a node. A method includes determining a current state of a target node. The current state of the target node refers to objects currently deployed or running in the remote target node. It includes at least one of an operating system, one or more applications, or configuration setting at the target node. The method further includes determining a desired state for the target node to change the current state. The method further includes accessing a dependency graph based on the version of an agent running on the target node. The dependency graph is supplied to a state machine. The state machine is particular to the target node. The state machine using the current state of the target node, the desired state and the dependency graph, performs operations to drive the target node toward its goal.

Josephson magnetic random access memory system and method

Abstract: One aspect of the present invention includes a Josephson magnetic random access memory (JMRAM) system The system includes an array of memory cells arranged in rows and columns Each of the memory cells includes an HMJJD that is configured to store a digital state corresponding to one of a binary logic-1 state and a binary logic-0 state in response to a word-write current that is provided on a word-write line and a bit-write current that is provided on a bit-write line The HMJJD is also configured to output the respective digital state in response to a word-read current that is provided on a word-read line and a bit-read current that is provided on a bit-read line

Intelligent game loading

Abstract: A computing system is configured to execute a computer program on a server and to provide a video stream of the program output to a geographically remote client over a communication network. The computing system is further configured to provide executable content of the computer program to the client over the communication network in parallel with the video stream. When a sufficient amount of the executable content has been provided to the client execution of the computer program is transitioned from the server to the client. The transition optionally includes communicating a state of the computer program from the server to the client. The executable content can be provided to the client in an order that is determined based on the state of the computer program. Those parts of the executable content deemed most likely to be necessary to support game play on the client are given priority.

Flash memory device and system with program sequencer, and programming method

Abstract: A programming method for a nonvolatile memory device includes performing a LSB programming operation programming all LSB logical pages, and thereafter performing a MSB programming operation programming all MSB logical pages, wherein during the LSB programming operation a selected MLC is programmed to a negative intermediate program state. A program sequence for the LSB and MSB programming operations may be sequential or non-sequential in relation to an order arranged of word lines.

Moving information between computing devices

Abstract: A computer-implemented method for moving information between computing devices includes capturing a digital image of a display of a first computing device using a camera of a second computing device, transmitting, to the first computing device, data that corresponds to the digital image; analyzing the transmitted data on the first computing device to determine whether the digital image matches a current display of the first computing device, and using the analysis to cause one of the first or second computing devices to invoke an application and match a state of an application that is executing on the other of the first or second computing devices.

The State of Patenting at Research Institutions in Developing Countries: Policy Approaches and Practices

Abstract: By granting universities and public research organizations (PROs) the rights to their own intellectual property (IP) - patents, copyrights, trademarks, utility models, industrial designs - derived from statefinanced research, and allowing them to commercialize their results, governments seek to accelerate the transformation of scientific discoveries into industrial applications, and to strengthen collaborative ties between the universities and industries. This study reviews the experience of advanced countries and discusses the opportunities and challenges offered by patents to foster technology transfer from government funded research institutions in developing countries. It presents a review of policy frameworks and recent policy changes aimed to foster academic patenting and technology transfer in low- and middle-income countries. It then analyzes patenting activities by universities and PROs and compares these trends with respect to high-income countries. This analysis is complemented with an assessment of the current state of patenting and technology commercialization practices in a selected group of technology transfer offices (TTOs). We finally discuss policy implications and the challenges developing countries face to build effective technology transfer systems and take full benefit of patents and other intellectual property rights.

Dual-mode program execution

Abstract: A computing system is configured to execute a computer program on a server and to provide a video stream of the program output to a geographically remote client over a communication network. The computing system is further configured to provide executable content of the computer program to the client over the communication network in parallel with the video stream. When a sufficient amount of the executable content has been provided to the client execution of the computer program is transitioned from the server to the client. The transition optionally includes communicating a state of the computer program from the server to the client. The executable content can be provided to the client in an order that is determined based on the state of the computer program. Those parts of the executable content deemed most likely to be necessary to support game play on the client are given priority.

System and Method for Remote Updates

Abstract: Software on a server accesses a batch file including a plurality of events generated by a remote game client application executing an instance of the computer-implemented game The software accesses a game state data object associated with the instance of the computer-implemented game The game state data object includes one or more game state parameters formatted as a serialized unstructured string of text data The software parses the game state data object to identify the one or more game state parameters The software processes the plurality of events in the batch file against game logic to update one or more of the game state parameters in the game state data object The game logic incorporates information extracted from a social graph And the software stores the game state data object in a memory cache

Profile-based message control

Abstract: A computer system includes a profile associated with one or more logic modules. Each logic module specifies a condition and a corresponding action. The profile may be applied to context data, such as messages transmitted over a network, to perform the actions specified by the logic modules in response to detecting that the context data satisfies the conditions specified by the logic modules. The profile may have an activation state, in which case the logic modules may be applied to the context data only if the profile's activation state indicates that the profile is active. One application of the system is to perform different actions (such as blocking, forwarding, deferring, and allowing) in connection with messages transmitted via different modes of communication (such as one or more of email communication, text messaging communication, and live voice call communication).