EXECUTION OFFLOADING THROUGH SYSCALL TRAP INTERFACE

Technologies for offloading execution of program code from a client computing device include a server to execute program code received from the client computing device. The server monitors execution of the program code to determine whether an instruction of the program code to be executed requires a system call. In response to determining the instruction requires execution of a system call, the server transmits the instruction to the client computing device for execution. The server receives a response from the client computing device in response to execution of the instruction that requires execution of the system call by the client computing device.

BACKGROUND

Power consumption, security, performance, features, and size are critical parameters in a constantly evolving computing ecosystem, particularly with the growing use of mobile computing devices. For example, mobile computing devices are oftentimes designed to minimize power consumption and device/component size while maximizing performance, security, and features. With the advent of shared computing mechanisms such as cloud computing, it is possible to offload execution from a local computing device (e.g., a mobile computing device) to a remote computing device (e.g., a server in a cloud computing environment). Typically, such execution offloading involves transferring the entire environment context from the local computing device to the remote computing device and/or modifications to the applications that are to be run remotely.

Computing devices generally use multiple modes of execution during the execution of an application. For example, a particular computing device may have a non-privileged mode in which a program is generally executed and a privileged mode in which an operating system kernel is executed. In order to access system resources or perform hardware-related services (e.g., accessing hard disc data), an executing program utilizes system calls to request a corresponding service to be performed by the operating system.

DETAILED DESCRIPTION OF THE DRAWINGS

Referring now toFIG. 1, a system100for offloading execution of program code includes a client computing device102, a network104, and a server106. In use, as described in more detail below, the client computing device102is configured to transmit program code (e.g., an application) to the server106for offloaded execution of the program code. If the server106encounters a program code instruction requiring a system call that should be executed by the client computing device102, the server106transmits the instruction to the client computing device102for execution. In some cases, both the client computing device102and the server106may execute the system call instruction.

The client computing device102may be embodied as any type of computing device capable of executing program code, communicating with the server106over the network104, and performing the functions described herein. For example, the client computing device102may be embodied as a cellular phone, smartphone, tablet computer, netbook, notebook, Ultrabook™, laptop computer, personal digital assistant, mobile Internet device, desktop computer, Hybrid device, and/or any other computing/communication device. As shown inFIG. 1, the illustrative client computing device102includes a processor110, an input/output (“I/O”) subsystem112, a memory114, a data storage116, a communication circuitry118, and one or more peripheral devices120. Of course, the client computing device102may include other or additional components, such as those commonly found in a typical computing device (e.g., various input/output devices), in other embodiments. Additionally, in some embodiments, one or more of the illustrative components may be incorporated in, or otherwise from a portion of, another component. For example, the memory114, or portions thereof, may be incorporated in the processor110in some embodiments.

The processor110may be embodied as any type of processor capable of performing the functions described herein. For example, the processor may be embodied as a single or multi-core processor(s), digital signal processor, microcontroller, or other processor or processing/controlling circuit. Similarly, the memory114may be embodied as any type of volatile or non-volatile memory or data storage capable of performing the functions described herein. In operation, the memory114may store various data and software used during operation of the client computing device102such as operating systems, applications, programs, libraries, and drivers. The memory114is communicatively coupled to the processor110via the I/O subsystem112, which may be embodied as circuitry and/or components to facilitate input/output operations with the processor110, the memory114, and other components of the client computing device102. For example, the I/O subsystem112may be embodied as, or otherwise include, memory controller hubs, input/output control hubs, firmware devices, communication links (i.e., point-to-point links, bus links, wires, cables, light guides, printed circuit board traces, etc.) and/or other components and subsystems to facilitate the input/output operations. In some embodiments, the I/O subsystem112may form a portion of a system-on-a-chip (SoC) and be incorporated, along with the processor110, the memory114, and other components of the client computing device102, on a single integrated circuit chip.

The data storage116may be embodied as any type of device or devices configured for short-term or long-term storage of data such as, for example, memory devices and circuits, memory cards, hard disk drives, solid-state drives, or other data storage devices. As shown inFIG. 1, the data storage116includes a translation table122. The translation table122maps correspondences between local memory addresses of the client computing device102and the server106as discussed in more detail below. The translation table122may be stored on the data storage116as any suitable data structure (e.g., a database).

The communication circuitry118may be embodied as any communication circuit, device, or collection thereof, capable of enabling communications between the client computing device102and other remote devices (e.g., the server106) over the network104. To do so, the communication circuitry118may use any suitable communication technology (e.g., wireless or wired communications) and associated protocol (e.g., Ethernet, Bluetooth®, Wi-Fi®, WiMAX, etc.) to effect such communication depending on, for example, the type of network, which may be embodied as any type of communication network capable of facilitating communication between the client computing device102and remote devices. The peripheral devices120of the client computing device102may include any number of additional peripheral or interface devices. The particular devices included in the peripheral devices120may depend on, for example, the type and/or intended use of the client computing device102.

The network104may be embodied as any type of communication network capable of facilitating communication between the client computing device102and the server106. As such, the network104may include one or more networks, routers, switches, computers, and/or other intervening devices. For example, the network104may be embodied as or otherwise include one or more local or wide area networks, publicly available global networks (e.g., the Internet), cellular networks, telephone networks, ad hoc networks, or any combination thereof.

The server106may be embodied as any type of computing device capable of performing the functions described herein. For examples, in some embodiments, the server106may be similar to the client computing device102as described above. That is, the server106may be embodied as an enterprise-level server computer, a desktop computer, a laptop computer, a tablet computer, a cellular phone, smartphone, personal digital assistant, mobile Internet device, netbook, notebook, Ultrabook™, Hybrid device, and/or any other computing/communication device. Further, the server106may include components similar to those of the client computing device102discussed above. For example, as shown in the illustrative embodiment ofFIG. 1, the server106includes a processor150, an I/O subsystem152, a memory154, a data storage156(e.g., for storing a translation table162), a communication circuitry158, and one or more peripheral devices160. The description of those components of the client computing device102is equally application to the description of corresponding components of the server106and is not repeated herein for clarity of the description. Further, it should be appreciated that the server106may include other components, sub-components, and devices commonly found in a computing device or server, which are not discussed above in reference to the client computing device102and not discussed herein for clarity of the description. The translation table162may be substantially similar to the translation table122discussed above and may map correspondences between local memory addresses of the server106and the client computing device102. Although two translation tables122,162are shown inFIG. 1, in some embodiments, a single translation table122,162is stored on only one of the client computing device102or the server106(i.e., not on both devices).

Referring now toFIG. 2, in use, the client computing device102of the system100establishes an environment200, and the server106of the system100establishes an environment250for offloaded execution of program code. As discussed below, the server106executes program code received from the client computing device102. If an instruction of program code requires execution of a system call by the client computing device102(e.g., to access a file), the server106transmits the instruction to the client computing device102for execution.

The illustrative environment200of the client computing device102includes a code management module204, a system call execution module206, and a communication module208. Furthermore, the environment250of the server106in the illustrative embodiment includes a code execution module252, a system call management module254, and a communication module256. Each of the code management module204, the system call execution module206, the communication module208, the code execution module252, the system call management module254, and the communication module256may be embodied as hardware, software, firmware, or a combination thereof. Additionally, in some embodiments, one of the illustrative modules may form a portion of another module (e.g., the code execution module252may form a portion of the system call management module254).

The code management module204of the client computing device102transmits program code to the server106over the network104for execution (e.g., via the communication module208). The program code may be embodied as, for example, one or more binary application files or other program code to execute an application202. As discussed below, in the illustrative embodiment, the program code is transmitted to the server106for execution without any modifications to the code. In response to receipt of the program code, the server106is configured to execute the transmitted program code. If the server106determines that an instruction of the program code includes a system call that requires execution by the client computing device102, the server106transmits the instruction to the client computing device102for execution. Accordingly, the code management module204of the client computing device102receives such instruction (e.g., with the communication module208).

The system call execution module206executes instructions received from the server106. That is, the system call execution module206executes instructions of the offloaded program code determined by the server106to include system calls requiring execution by the client computing device102. The system call execution module206(i.e., in conjunction with the communication module208) transmits a response (e.g., a result of the system call and/or memory mapping data) to the server106based on the execution of the system call. Additionally, as discussed in greater detail below, the system call execution module206may translate an address of the system call between a memory address of the server106and a memory address of the client computing device102, allocate memory in a local context of the client computing device102(e.g., in the memory114or the data storage116), and/or update the translation table122(e.g., based on memory allocation).

The communication module208handles the communication between the client computing device102and remote devices (e.g., the server106) through the network104. As discussed above, the code management module204and the system call execution module206communicate with the server106via the communication module208regarding instructions involving system calls.

As shown inFIG. 2, the server106includes the code execution module252, the system call management module254, and the communication module256. The code execution module252loads and executes the program code received from the client computing device102for execution. Additionally, in some embodiments, the code execution module252initializes the translation table162(e.g., during the loading of the program code) that translates addresses between memory addresses of the server106and memory addresses of the client computing device102. Depending on the particular instruction of the program code executed, the code execution module252and/or the system call management module254may translate an address associated with a system call and/or update the translation table162based on execution of an instruction (e.g., an instruction requiring a system call).

The system call management module254monitors execution of the program code (i.e., the program code received from the client computing device102and executed by the code execution module252) to determine whether an instruction of the program code to be executed requires a system call. In some embodiments, the system call management module254“traps” or intercepts any program code that initiates a system call. If a system call is identified and determined to require execution by the client computing device102, the system call management module254transmits the instruction and, if needed, related content/data to the client computing device102for execution (e.g., via the communication module256). Subsequently, the system call management module254receives a response from the client computing device102in response to execution of the instruction requiring execution of the system call by the client computing device102.

It should be appreciated that the particular system calls, types of system calls, or instructions requiring execution by the client computing device102and/or the server106may vary depending on the particular embodiment and/or the offloaded program code. The system calls requiring execution by the client computing device102may include, for example, read, write, open, close, memory allocation, and other system calls. As shown inFIG. 2, an execution policy database258may be stored on the server106(i.e., as a suitable data structure) or may be otherwise accessible by the server106(e.g., stored on a remote device and accessible over the network104). In the illustrative embodiment, the execution policy database258identifies the system calls to be handled by the client computing device102, the system calls to be handled by the server106, and/or the system calls to be handled by both the client computing device102and the server106. In some embodiments, the execution policy database258may be received from, or otherwise updated by, the client computing device102. For example, execution policies to be stored in the execution policy database258may be transmitted, along with the program code, by the client computing device102to the server106. Such execution policies may be developed or defined by, for example, the designer of the program code. Additionally or alternatively, the execution policies may be determined or inferred by the server106(e.g. based on generic system calls). Regardless, the system call management module254compares identified system calls (or the instructions requiring the system calls) to the execution policy database258to determine how to handle each of the system calls. That is, the execution policy database258includes a list of system calls and identifies how each system call is to be handled locally (if at all) and remotely (if at all).

The communication module256of the server106may be similar to the communication module208of the client computing device102. That is, the communication module256handles the communication between the server106and remote devices (e.g., the client computing device102) through the network104. As discussed above, the code execution module252and the system call management module254communicate with the client computing device102via the communication module256regarding instructions involving system calls. In some embodiments, the communication module256and the communication module208establish a secure communication link between the server106and the client computing device102for transmitting instructions and data related to system calls.

Referring now toFIG. 3, in use, the server106of the system100may execute a method300for offloading execution of program code from the client computing device102to the server106. The illustrative method300begins with block302ofFIG. 3in which the server106determines whether to offload execution. It should be appreciated that, in some embodiments, the server106determines to offload execution in response to receiving program code for execution from the client computing device102. As such, in block304, the server106receives program code from the client computing device102in block304. As discussed above, the program code may be embodied as one or more unmodified binary application files. In other words, the client computing device102may transmit the application files that the client computing device102would execute without modification to the server106for remote execution by the server106. Additionally, as discussed above, the server106may receive execution policies defining system calls requiring execution by the client computing device102along with the program code in block304in some embodiments. In such embodiments, the server106stores any received execution policies in the execution policy database258.

In block306, the server106loads and executes the program code received from the client computing device102. In doing so, the server106may initialize one or more translation tables for storing information regarding mappings/correspondences between local memory addresses of the client computing device102and the server106in block308. In block310, the server106determines whether the next instruction to be executed requires a system call. As discussed above, in some embodiments, the server106monitors the execution of the program code and “traps” the program code or generates an intercept if a system call is encountered, and the execution policy database258of the server106may include a list of instructions or system calls to trap.

If the server106determines the instruction does not require a system call, the server106executes the instruction in block312. In other words, the server106continues executing the instructions of the program code received from the client computing device102until a system call is encountered. If the instruction is a system call, in block314, the server106determines whether the system call requires execution by the client computing device102. As indicated above, in order to make that determination, the server106may compare the instruction or system call to the execution policy database258of the server106. The execution policy database258may indicate, for example, whether a particular type of system call or instruction requires execution by the client computing device102and/or the server106. If the system call requires execution by the client computing device102, the server106transmits the instruction requiring the system call to the client computing device102in block316. Additionally, in block318, the server106may transmit data associated with one or more parameters of the system call (e.g., a filename stored in the memory154and identified by a pointer) and/or other data/contents of the memory154related to execution of the system call and/or related system calls (e.g., subsequent system call). For example, in one embodiment, the system call may be an “open( )” system call that takes two parameters—a pointer to a memory location holding the filename and a mode. As discussed herein, each of the server106and the client computing device102allocate memory for the filename and establish a pointer mapping in the translation table,122,162. Additionally, at some point (e.g., contemporaneously with transmission of the instruction including the system call), the server106transmits the filename data to the client computing device102, which the client computing device102stores in the appropriate memory location (i.e., based on the mapping stored in the translation table122,162). In doing so, the client computing device102is able to access the appropriate file related to the system call and/or subsequent related system call (e.g., system calls to access the same file).

Subsequently, in block320, the server106may receive a response from the client computing device102based on execution of the transmitted system call by the client computing device102. The contents of the response may vary depending on the particular embodiment and may include, for example, status information regarding the execution of the system call, data returned from the kernel of the client computing device102based on the system call, memory mapping data based on a memory allocation on the client computing device102and/or a mapping between a memory address of the server106and the client computing device102, and/or other information related to the instruction or system call. In some embodiments, the client computing device102may execute the system call without providing a response to the server106.

If the server106determines in block314that the system call does not require execution by the client computing device102or after receiving any response from the client computing device102in block320, the method300advances to block322. In block322, the server106determines whether the system call requires execution by the server106. It should be appreciated that the timing of such a determination may vary by embodiment. For example, in some embodiments, the server106may determine whether the system call requires execution by the server106contemporaneously with the determination of whether the system call requires execution by the client computing device102(e.g., by comparing the system call or type of system call to the execution policy database258).

If the system call does not require execution by the server106, the method300returns to block310in which the server106determines whether the next instruction requires a system call. That is, the server106executes the program code until another system call is encountered. If, however, the system call requires execution by the server106, the server106executes the system call in block324. In doing so, the server106may translate the address of the system call in block326. For example, as discussed above, a system call may require execution by both the client computing device102and the server106. Accordingly, the server106may translate an address of the system call or address related to the system call (e.g., related to memory allocation) between a memory address of the server106and a memory address of the client computing device102. Additionally or alternatively, the server106may update the translation table162in block328. For example, the server106may update the translation table162based on memory or address modifications (e.g., memory allocation) that occurred with respect to the execution of the system call by the server106. If the system call does not require execution by the server106or in response to execution of the system call by the server106, the method300returns to block310in which the server106determines whether the next instruction requires a system call. It should be appreciated that, in some embodiments, one or more of the blocks302-328may be performed in parallel (e.g., blocks314-320in parallel with blocks322-328) or in another order than the order presented inFIG. 3.

Referring now toFIG. 4, in use, the client computing device102of the system100may execute a method400for offloading execution of program code from the client computing device102to the server106. The illustrative method400begins with block402ofFIG. 4in which the client computing device102determines whether to offload execution. If so, the client computing device102transmits the program code to the server106for execution in block404. As discussed above, it is unnecessary in the illustrative embodiment to make any modifications to the program code or to transmit the context of the client computing device102in order to offload execution of the program code to the server106. Additionally, as discussed above, the client computing device102may also transmit, along with the program code, execution policies defining system calls requiring execution by the client computing device102in block404.

After some time, which is delineated inFIG. 4by the double-tilde symbol, the client computing device102determines, in block406, whether a system call has been received from the server106. As discussed above, after the client computing device102transmits the program code to the server106for execution, the server106loads and executes the program code. If the server106traps, or otherwise identifies, an instruction that requires a system call to be executed by the client computing device102, the server106transmits the instruction and/or system call to the client computing device102for execution.

As such, if the client computing device102receives a system call from the server106for execution, the client computing device102determines whether the system call requires address/memory translation in block408. In some embodiments, the client computing device102may make such a determination based on the particular system calls received (e.g., by comparing the system call to a database similar to the execution policy database258of the server106). In other embodiments, the server106may transmit a supplementary instruction indicating how the client computing device102should process, execution, or otherwise handle the program code instruction or system call.

If the client computing device102determines the system call requires address/memory translation, the client computing device102may translate an address of the system call in block410. For example, as discussed above, the client computing device102may translate an address of the system call (or an address related to the system call) between a memory address of the server106and a memory address of the client computing device102. In block412, the client computing device102may allocate memory in a local context of the client computing device102. The client computing device102may update the translation table122(e.g., based on the memory allocation) in block414. For example, the server106may encounter a system call requiring the allocation of memory (e.g., to write a file), which the server106executes but also transmits to the client computing device102for execution (i.e., memory allocation) on the client computing device102. Both the server106and the client computing device102may allocate memory in the corresponding local context. Because the program code is executed on the server106, the program code will utilize the memory allocated on the server106; however, the write operation is directed to writing a file on the client computing device102. As such, the client computing device102and the server106utilize one or both of the translation tables122,162to translate between addresses of the client computing device102and the server106. Additionally, the translation tables122,162are updated based on any relevant address modifications.

In block416, the client computing device102executes the system call received from the server106. It should be appreciated that the translation, allocation, and/or updating of blocks410-414may be performed as a part of the execution of the system call in some embodiments. In block418, the client computing device102transmits a system call response to the server106based on the execution of the system call. As discussed above, the contents of the response may vary depending on the particular embodiment and may include a variety of information related to the execution of the system call by the client computing device102. In response to transmitting the response to the server106, the method400returns to block406in which the client computing device102determines whether a system call has been received from the server106. That is, the client computing device102waits until the server106transmits a system call requiring execution by the client computing device102.

Examples

Example 1 includes a server for offloading execution of program code from a client computing device, the server comprising a code execution module to execute the program code received from the client computing device; and a system call management module to (i) monitor execution of the program code to determine whether an instruction of the program code to be executed requires a system call, (ii) transmit the instruction to the client computing device for execution in response to a determination that the instruction requires execution of a system call, and (iii) receive a response from the client computing device in response to execution of the instruction that requires execution of the system call by the client computing device.

Example 2 includes the subject matter of Example 1, and wherein the system call management module is further to determine whether the instruction determined to require a system call requires execution by the client computing device, and wherein to transmit the instruction to the client computing device comprises to transmit the instruction to the client computing device for execution in response to a determination that the instruction requires execution by the client computing device.

Example 3 includes the subject matter of any of Examples 1 and 2, and wherein the system call management module is further to determine whether the instruction determined to require a system call requires execution by the server in response to a determination the instruction does not require execution by the client computing device; and the code execution module is further to execute the instruction determined to require the system call in response to a determination that the instruction requires execution by the server.

Example 4 includes the subject matter of any of Examples 1-3, and wherein the system call management module is further to determine whether the instruction determined to require a system call requires execution by the server in response to a determination that the instruction requires execution by the client computing device; and the code execution module is further to execute the instruction determined to require the system call in response to a determination that the instruction requires execution by the server.

Example 5 includes the subject matter of any of Examples 1-4, and wherein to load the program code comprises to initialize an address/memory translation table that translates addresses between memory addresses of the server and memory addresses of the client computing device.

Example 6 includes the subject matter of any of Examples 1-5, and wherein to execute the instruction that requires execution of the system call comprises to translate an address associated with the system call between a memory address of the server and a memory address of the client computing device.

Example 7 includes the subject matter of any of Examples 1-6, and wherein to execute the instruction that requires execution of the system call comprises to update a translation table based on the execution of the instruction that requires the system call.

Example 8 includes the subject matter of any of Examples 1-7, and wherein the code execution module is further to execute the instruction in response to a determination that the instruction to be executed does not require a system call.

Example 9 includes the subject matter of any of Examples 1-8, and further including a communication module to receive, from the client computing device, the program code to be executed by the server.

Example 10 includes a method for offloading execution of program code from a client computing device to a server, the method comprising loading, by the server, the program code received from the client computing device for execution; determining, by the server, whether an instruction of the program code to be executed requires a system call; transmitting, from the server, the instruction to the client computing device for execution in response to determining the instruction requires execution of a system call; and receiving, by the server, a response from the client computing device in response to execution of the instruction requiring execution of the system call by the client computing device.

Example 11 includes the subject matter of Example 10, and further including determining, by the server, whether the instruction determined to require a system call requires execution by the client computing device, wherein transmitting the instruction to the client computing device comprises transmitting the instruction to the client computing device for execution in response to determining the instruction requires execution by the client computing device.

Example 12 includes the subject matter of any of Examples 10 and 11, and further including determining, by the server, whether the instruction determined to require a system call requires execution by the server in response to determining the instruction does not require execution by the client computing device; and executing, by the server, the instruction determined to require the system call in response to determining the instruction requires execution by the server.

Example 13 includes the subject matter of any of Examples 10-12, and further including determining, by the server, whether the instruction determined to require a system call requires execution by the server in response to determining the instruction requires execution by the client computing device; and executing, by the server, the instruction determined to require the system call in response to determining the instruction requires execution by the server.

Example 14 includes the subject matter of any of Examples 10-13, and wherein loading the program code comprises initializing an address/memory translation table that translates addresses between memory addresses of the server and memory addresses of the client computing device.

Example 15 includes the subject matter of any of Examples 10-14, and wherein execution of the instruction requiring execution of the system call comprises translating an address associated with the system call between a memory address of the server and a memory address of the client computing device.

Example 16 includes the subject matter of any of Examples 10-15, and wherein execution of the instruction requiring execution of the system call comprises updating a translation table based on the execution of the instruction requiring the system call.

Example 17 includes the subject matter of any of Examples 10-16, and further including executing, by the server, the instruction in response to determining the instruction to be executed does not require a system call.

Example 18 includes the subject matter of any of Examples 10-17, and further including receiving, by the server and from the client computing device, the program code to be executed by the server.

Example 20 includes one or more machine-readable storage media comprising a plurality of instructions stored thereon that, in response to being executed, result in a computing device performing the method of any of Examples 10-18.

Example 21 includes a computing device for offloading execution of program code from a client device, the computing device comprising means for loading the program code received from the client device for execution; means for determining whether an instruction of the program code to be executed requires a system call; means for transmitting the instruction to the client device for execution in response to determining the instruction requires execution of a system call; and means for receiving a response from the client device in response to execution of the instruction requiring execution of the system call by the client computing device.

Example 22 includes the subject matter of Example 21, and further including means for determining whether the instruction determined to require a system call requires execution by the client device, wherein the means for transmitting the instruction to the client device comprises means for transmitting the instruction to the client device for execution in response to determining the instruction requires execution by the client device.

Example 23 includes the subject matter of any of Examples 21 and 22, and further including means for determining whether the instruction determined to require a system call requires execution by the server in response to determining the instruction does not require execution by the client device; and means for executing the instruction determined to require the system call in response to determining the instruction requires execution by the server.

Example 24 includes the subject matter of any of Examples 21-23, and further including means for determining whether the instruction determined to require a system call requires execution by the server in response to determining the instruction requires execution by the client device; and means for executing the instruction determined to require the system call in response to determining the instruction requires execution by the server.

Example 25 includes the subject matter of any of Examples 21-24, and wherein the means for loading the program code comprises means for initializing an address/memory translation table that translates addresses between memory addresses of the server and memory addresses of the client device.

Example 26 includes the subject matter of any of Examples 21-25, and wherein means for execution of the instruction requiring execution of the system call comprises means for translating an address associated with the system call between a memory address of the server and a memory address of the client device.

Example 27 includes the subject matter of any of Examples 21-26, and wherein means for execution of the instruction requiring execution of the system call comprises means for updating a translation table based on the execution of the instruction requiring the system call.

Example 28 includes the subject matter of any of Examples 21-27, and further including means for executing the instruction in response to determining the instruction to be executed does not require a system call.

Example 29 includes the subject matter of any of Examples 21-28, and further including means for receiving, from the client device, the program code to be executed by the server.

Example 30 includes a client computing device for offloading execution of program code to a server, the client computing device comprising a code management module to (i) transmit the program code to the server for offloaded execution and (ii) receive, during execution of the program code by the server, an instruction of the program code determined by the server to include a system call; and a system call execution module to execute the instruction determined to include the system call, wherein the communication module is further to transmit, to the server, a response based on the execution of the system call by the client computing device.

Example 31 includes the subject matter of Example 30, and wherein the system call execution module is further to (i) determine whether the received instruction determined to require a system call requires address/memory translation (ii) translate an address of the system call between a memory address of the server and a memory address of the client computing device in response to a determination that the system call requires address/memory translation.

Example 32 includes the subject matter of any of Examples 30 and 31, and wherein the system call execution module is to (i) allocate memory in a local context of the client computing device in response to a determination that the system call requires address/memory translation and (ii) update a translation table based on the memory allocation.

Example 33 includes the subject matter of any of Examples 30-32, and wherein to transmit the response to the server comprises to transmit memory mapping data to the server; and wherein the memory mapping data is based on a mapping between a memory address of the server and a memory address of the client computing device.

Example 34 includes a method for offloading execution of program code from a client computing device to a server, the method comprising transmitting, from the client computing device, the program code to the server for offloaded execution; receiving, by the client computing device and during execution of the program code by the server, an instruction of the program code determined by the server to require a system call; executing, by the client computing device, the instruction determined to require the system call; and transmitting, from the client computing device and to the server, a response based on the execution of the system call by the client computing device.

Example 35 includes the subject matter of Example 34, and further including determining, by the client computing device, whether the received instruction determined to require a system call requires address/memory translation; and translating, by the client computing device, an address of the system call between a memory address of the server and a memory address of the client computing device in response to determining the system call requires address/memory translation.

Example 36 includes the subject matter of any of Examples 34 and 35, and further including allocating, by the client computing device, memory in a local context of the client computing device in response to determining the system call requires address/memory translation; and updating, by the client computing device, a translation table based on the memory allocation.

Example 37 includes the subject matter of any of Examples 34-36, and wherein transmitting the response to the server comprises transmitting memory mapping data to the server, wherein the memory mapping data is based on a mapping between a memory address of the server and a memory address of the client computing device.

Example 39 includes one or more machine-readable storage media comprising a plurality of instructions stored thereon that, in response to being executed, result in a computing device performing the method of any of Examples 34-37.

Example 40 includes a computing device for offloading execution of program code to a server, the computing device comprising means for transmitting the program code to the server for offloaded execution; means for receiving, during execution of the program code by the server, an instruction of the program code determined by the server to require a system call; means for executing the instruction determined to require the system call; and means for transmitting, to the server, a response based on the execution of the system call by the computing device.

Example 41 includes the subject matter of Example 40, and further including means for determining whether the received instruction determined to require a system call requires address/memory translation; and means for translating an address of the system call between a memory address of the server and a memory address of the computing device in response to determining the system call requires address/memory translation.

Example 42 includes the subject matter of any of Examples 40 and 41, and further including means for allocating memory in a local context of the computing device in response to determining the system call requires address/memory translation; and means for updating a translation table based on the memory allocation.

Example 43 includes the subject matter of any of Examples 40-42, and wherein the means for transmitting the response to the server comprises means for transmitting memory mapping data to the server; and wherein the memory mapping data is based on a mapping between a memory address of the server and a memory address of the computing device.