Scalable architecture

Abstract

Exemplary embodiments may employ techniques for dynamically dispatching requests to resources operating in a distributed computing environment, such as a computing cloud, according to one or more policies. Embodiments may further dynamically adjust resources in the computing environment using predictive models that use current loads as an input. Embodiments may still further maintain a state for a processing environment independent of the type or configuration of a device used to access the environment on behalf of a user.

What is claimed is: 
     
         1 . One or more computer-readable media holding executable instructions that when executed on processing logic dynamically dispatch a request associated with a technical computing environment, the media holding one or more instructions for:
 identifying a request for a service provided by one or more of a plurality of remote devices in a distributed processing environment that includes one or more technical computing environments;   accessing a data structure holding a plurality of policies for dynamically determining at least one of the plurality of remote devices for providing the service to a device making the request, where:
 the at least one of the plurality of remote devices is available and configured to provide the service, and 
 the service is used to satisfy the request; 
   selecting at least one policy from the plurality of policies in the data structure, the at least one selected policy including one or more of:
 a security policy, 
 a cost policy, 
 a bandwidth policy, 
 a state policy, 
 a latency policy, 
 a configuration policy, 
 a location policy, 
 a quality-of-service policy, 
 a topology policy, 
 an affiliation policy, 
 a licensing policy, 
 a rights policy, and 
 an accuracy policy; 
   applying the selected at least one policy to the request;   identifying at least one of the plurality of remote devices that complies with the selected at least one policy, where complying with the policy indicates that the at least one of the plurality of remote devices will satisfy the request; and   dynamically dispatching the request to the identified at least one of the plurality of remote devices complying with the selected at least one policy.   
     
     
         2 . The computer-readable media of  claim 1 , where the media further holds one or more instructions for:
 generating a result using the identified at least one of the plurality of remote devices complying with the selected at least one policy; and   returning the result to the requesting device.   
     
     
         3 . The computer-readable media of  claim 1 , where the technical computing environment is a MATLAB programming environment or a MATLAB-compatible programming environment. 
     
     
         4 . One or more computer-readable media holding executable instructions that when executed on processing logic proactively scale distributed computing resources, the media holding one or more instructions for:
 providing a processing buffer in a distributed computing environment, where:
 the distributed computing environment includes a technical computing environment, 
 the processing buffer represents a determined amount of excess processing resources, and 
 the excess processing resources provide additional distributed processing capabilities to the distributed computing environment when the excess processing resources are engaged; 
   measuring a processing load for the distributed computing environment;   dynamically updating a model with the measured processing load, where the model:
 determines whether a size of the processing buffer is adequate, 
 receives additional information, and 
 includes one or more algorithms that use the measured processing load and the additional information to produce a result; 
   evaluating the result to determine whether:
 the size of the processing buffer is adequate, or 
 the size of the processing buffer is inadequate, where an inadequate processing buffer size indicates one of:
 the processing buffer size is smaller than desired, or 
 the processing buffer size is larger than desired; and 
 
   increasing the size of the processing buffer when the size of the processing buffer is smaller than desired by making additional distributed processing resources available to the distributed computing environment, or decreasing the size of the processing buffer when the size of the processing buffer is larger than desired by making some of the distributed processing resources unavailable in the distributing computing environment.   
     
     
         5 . The computer-readable media of  claim 4 , where the additional information includes one or more of:
 historical data for the distributed computing environment,   rate-of-change information for the distributed computing environment,   event information for one or more events, where the events are internal or external to the distributed computing environment, and   status information for devices in the distributed computing network.   
     
     
         6 . The computer-readable media of  claim 4 , where the processing buffer supports dynamically moving a processing job among distributed processing resources while the job is running. 
     
     
         7 . The computer-readable media of  claim 4 , where the processing buffer supports synchronized execution between two or more programs using the distributed processing resources. 
     
     
         8 . One or more computer-readable media holding executable instructions that when executed on processing logic maintain device independent state for a technical computing environment associated with a user, the media holding one or more instructions for:
 initiating a technical computing environment in response to an instruction received from a user, where the technical computing environment is initiated on a first device associated with the user;   performing a first operation on behalf of the user, where the first operation is performed using the technical computing environment on the first device;   storing a state for the technical computing environment, where the state:
 represents a status of the technical computing environment with respect to the first device, and 
 includes one or more of:
 information about the first operation, 
 a variable, 
 data, 
 an output, 
 a sample time, 
 an event, 
 a configuration, 
 a flag, 
 an error message, 
 a device identifier, and 
 an operating system identifier; 
 
   receiving an instruction from a second device, where the second device is associated with the user;   loading the state when the instruction is received from the second device,   providing access to the technical computing environment to the user via the second device, where the access reflects the state of the technical computing environment on the first device; and   maintaining a synchronized state on the first device, where the synchronized state:
 updates the state on the first device in response to inputs received from the user via the second device, 
 updates a state on the second device, where the updated state on the second device is substantially the same with respect to the user as the updated state on the first device, and 
 provides the updated state to the user when the user accesses the technical computing environment from the first device. 
   
     
     
         9 . The computer-readable media of  claim 8 , where the synchronized state is maintained with a device providing a quick command window to a user.