Abstract:
System and method for allowing embedded devices, even with a limited amount of CPU power and limited memory, to run code more efficiently by eliminating all or most of the runtime checks, while retaining the benefits of runtime checks. The runtime checks may be moved or duplicated to an outside application running on a remote computer. The outside application can prepare the runtime checks for execution at the embedded system. The embedded system may receive pre-validated code and store it inside custom cache for later execution using a check-less, or check-limited, runtime on the embedded device.

Description:
FIELD OF INVENTION 
   The present invention is system and method for performing runtime checks within a preparation application located outside embedded devices and more particularly for using a custom assembly cache to receive and store pre-validated assembly code into the embedded device for execution. 
   BACKGROUND 
   Embedded devices are able to run specific task related functions to provide some fixed functionalities (e.g., RFID chips). Many high-end devices are able to download and execute external code in order to provide added functionality. Embedded devices may include, but are not limited to, consumer electronics, medical devices, vending machines, point of sale terminals and other devices. Functionalities may include the ability to process financial transactions, perform detailed calculations and human automation, among many other functions. Embedded devices may be allowed to execute code for performing these various functions. However, to ensure the code functions correctly, multiple runtime checks may need to be performed. Runtime checks are a mechanism to check for error conditions at execution time, in contrast to checks done by the programming language and compilers (called compile-time checks) which only check for syntactical and type-related errors. Some of the runtime checks occur at startup, wherein the program is terminated if an error is found during the checks (e.g., a missing dependency, lack of certain hardware, etc.). Other runtime checks occur during the application execution and generally, throw exceptions if a check fails. Many of the runtime checks could be done prior to starting the application execution. 
   Recent embedded devices have begun to use virtual machines (VM), like the ECMA 335 VM, in order to provide increased platform portability and a richer development environment for devices. The increased portability is possible because VM converts code into machine language and executes it and may create an environment between a computer platform and the end user (e.g., embedded device) in which the end user can operate software applications properly. During runtime the virtual machine and assembly code may be used together to run an application. A more rich development environment is inherited from all the software available on the personal computer to support the VM. While this may solve issues related to using embedded devices, it also introduces new problems as well including as adding VM specific requirements (e.g., multiple runtime checks) that may need to be performed on an embedded device with limited resources. 
   Performing runtime checking has been known to slow down performance and VM requires even more runtime checks than the traditional approach which uses native code. In performance critical applications, some of the runtime check may be switched off. The downside to this being that the application may not execute properly if a check fails during execution (e.g. crash or wrong results). In addition, to keep cost down, embedded devices often have very limited CPU power and very limited memory, and this may be a source of many problems. For example, smaller devices, such as PDA&#39;s and other hand held computing devices, while convenient, usually have less memory, disk space, and resources than a personal computer. During runtime, many checks on code are completed before execution begins, which means a large amount of code is required to implement the runtime check. However, this does not add visible functionality to the application. Additional processing time may also be needed to verify all the code cases. The quantity of checks can differ between different runtimes. Some runtime standards (e.g., ECMA-335 Common Language Infrastructure (CLI)) may be heavier on verification requirements than others (e.g., loading an assembly, verifying the metadata, etc.). This presents code size and time issues both of which may be limited resources on embedded devices. There is a need for providing embedded devices having limited resources with the efficient method for providing runtime checking without the disadvantages of slowing down performance. 
   SUMMARY 
   Various aspects of the invention, overcome at least some of these and other drawbacks of known systems. According to one aspect of the invention, an embedded system may implement a check-less, or check-limited, runtime including a custom assembly cache used to store pre-validated code. Non-permanent communication means may be implemented between the embedded device and a computer having a code library and assembly preparation application which allows the checks to be done outside the embedded device itself. At this stage the embedded system may execute the check-less runtime using the assembly information from custom, trusted, assembly cache. 
   According to another aspect of the invention, an embedded system may communicate via network connection to receive updated and pre-validated code from remote sources on the network (e.g., pull model). 
   According to another aspect of the invention a preparation application may schedule the transmission of updated and pre-validated updates for multiple embedded devices running on a network (e.g., a push model). 
   The invention provides a solution for keeping the advantages of running all the code checks for smaller embedded devices without much of their inconveniences. These and other objects, features and advantages of the invention will be apparent through the detailed description of the embodiments and the drawings attached hereto. It is also to be understood that both the foregoing general description and the following detailed description are exemplary and not restrictive of the scope of the invention. 

   
     DESCRIPTION OF DRAWINGS 
       FIG. 1  is a high-level block diagram for a system; according to an embodiment of the invention. 
       FIG. 2  is a flow chart for a “generic model” method, according to an embodiment of the invention. 
       FIG. 3  is a flow chart for a “push model” method, according to an embodiment of the invention. 
       FIG. 4  is a flow chart for a “pull model” method, according to an embodiment of the invention. 
   

   DETAILED DESCRIPTION 
   Embedded devices may run using code that has been checked for runtime errors without actually running the runtime checking procedures locally on the embedded device or system. An embedded device may include a virtual machine for running applications and may further include runtime libraries for execution of applications. Runtime checks may be moved (or duplicated) outside of the embedded device into a preparation application executed from a computer (or an embedded device) capable of running the code checks. Code checking may check for runtime errors including errors in code syntax and/or logic. For example, recent VM, like ECMA-335, require multiple checks to validate assembly structure and metadata in order to ensure safe execution. Runtime checking before an application executes on a system may prevent runtime errors from occurring during execution on an embedded device. 
     FIG. 1  is a high level diagram of an embedded system (or device)  100  connected to a remote computer  120 , according to one aspect of the invention. The embedded system (or device)  100  may have limited memory and/or processing resources. An embedded system  100  may be used at various locations and environments including, but not limited to, consumer kiosk, consumer electronics, point of sale terminals, personal communication devices, and/or vending machine. A virtual machine  102  may be implemented to run applications on the embedded system  100 . The embedded system can include a permanent or a temporary communication means over a network  110  to remote computer  120 . Although, referred to as “remote” the computer  120  may also be implemented locally with respect to the embedded device or at a physically separate machine. The remote computer  120  may be any host computer, personal computer, or another embedded device, with memory and processing resources capable of greater execution power than the embedded device  100 . 
   While the implementations of an embedded device may vary, the need for highly functional code remains. Thus, the virtual machine  102  may be implemented, at least in part, to run diverse application code on an embedded device  100 . Applications may require a multiple number of files and/or assemblies in order to execute properly. An embedded device may run assemblies, although, according to the invention, assembly runtime checks may be moved (or duplicated) to outside of the device  100  into a library  108  on the remote computer  120 . Assembly information may be moved (or duplicated) and stored at the remote computer  120  within the code library  108 . The library  108  can be used independently of the embedded device&#39;s runtime. An outside application may be used to prepare the assemblies for the check-less runtime on the embedded device  100 . An outside application may be referred to as an assembly preparation application  112  and can run the checks that may be necessary or desired for the application to execute without runtime errors on the embedded device  100 . The assembly preparation application  112  may be run one (or more) times (e.g., on a PC) before the assembly is loaded back (or sent) to the embedded device  100 . 
   After the preparation application  112  executes, the checked assemblies may be loaded into a custom assembly cache  104 , which may be a separate assembly cache from other assembly caches that may already exist on the embedded device. The custom assembly cache  104  may be implemented in the embedded system in flash memory (or other temporary memory) to receive assemblies from the assembly preparation application  112  on the remote computer  120  or other source. A “check-less” embedded runtime may then be executed on the embedded device using assemblies from the custom assembly cache  104 . This enables the embedded device  100  to retain all the advantages of the checks without the code size and time penalties. Embedded devices without a custom assembly cache  104  can also exist and depend on the network availability of the computer  120  to download the pre-validated code directly during runtime execution. 
     FIG. 2  is a flow diagram for a method according to one aspect of the invention. The method disclosed in  FIG. 2  is a “generic” model implementation for preparing runtime checks. Before an application can be executed on a “check-less” or “check-limited” runtime, code validation operation may be required (operation  2 ). At such time the computer  120  may execute the assembly preparation application  112  to pre-validate, and potentially modify, the code (operation  4 ). Some runtime checks may include, but are not limited to, LinkDemand (JIT time) and the InheritanceDemand (load-time). Other stack-oriented actions including program Demands and program Asserts, could also be performed by the assembly preparations application  112  if the embedded device  100  operates with a fixed security policy. In which case, the preparation application could resolve policy issues and remove actions that are not allowed by the code so that when the code runs on the embedded device, security exceptions based on policy violation may be avoided. Once the code is pre-validated it may be stored at library  108  (operation  6 ) and subsequently “pushed to” (see  FIG. 3 ) and/or “pulled from” (see  FIG. 4 ) the embedded system  100  (operation  8 ). 
   After the assembly has been checked or “prepared” for use on the embedded device, the assembly information may be loaded onto the device at the custom assembly cache which may be ready to accept assemblies coming from the preparation application (operation  8 ). The embedded device may execute (operation  10 ) a check-less, or check-limited, runtime with the benefits of checked assembly code by using the assemblies received and stored at custom assembly cache  104 . 
     FIG. 3  is flow diagram for the “push” model. According to another aspect of the invention, a system of the present invention may be used for performing remote updates and installation of assembly code initiated by a remote source, for example the computer  120 . A network connection  110  (e.g., internet, LAN, WAN, etc.) may allow remote updates and installation on the embedded system  100  by a remote source. Assemblies may be prepared (operation  20 ), manually or automatically, by an application located on a networked resource and, optionally, stored into the library  108  (operation  22 ). The preparations involve performing runtime checks on the code, and possibly modifying the code, before transmitting (operation  24 ) and installing it (operation  26 ) to a network embedded device  100 . Updates may also be scheduled for distribution to multiple embedded devices  100  running on the network. Finally the embedded system  100  may execute (operation  28 ) from the custom assembly cache. 
     FIG. 4  is flow diagram for the “pull” model. According to another aspect of the invention, a system of the present invention may be used to allow independent updates and installation of the code. In this case, the embedded system  100  decides (operation  40 ), for example at startup, to retrieve updated pre-validated, code by communicating with (operation  22 ) a known computer  120  to get the updates. If updated code is available it may be installed (operation  44 ) into the custom assembly cache and executed on the embedded device (operation  46 ) when needed. The pull model may be useful, for example, when the embedded devices are not always active (e.g. a car micro-controller) or part of the network  110  (e.g. cell phones). 
   Although the current invention is described with respect to embedded devices, any “thin client” or computer offering secure storage may be used. In the foregoing specification, the invention has been described with reference to specific embodiments thereof. Various modifications and changes may be made thereto without departing from the broader spirit and scope of the invention. The specification and drawings are, accordingly, to be regarded in an illustrative rather than a restrictive sense.