Microsoft Technology Licensing, LLC

Gaurav Seth

Geoffrey M Kizer

Amanda K Silver

Stefan R Batres

Jianchun Xu

Jennifer A Hamilton

Koundinya Veluri

Michael C Fanning

Yong Qu

Lucas James Hoban

Curtis Man

Hitesh Kanwathirtha

Caroline G Murdoch

Methods, systems, and products are provided for thread-agile dynamic programming language ('DPL') program execution. Thread-agile DPL program execution may be carried out by receiving, in a message queue, a message for an instance of a DPL program and determining whether the host application has a stored state object for the instance of the DPL program identified by the message. If the host application has a stored state object for the DPL program, thread-agile DPL program execution may also carried out by retrieving the state object; preparing a thread available from a thread pool for execution of the instance of the DPL program in dependence upon the state object and an execution context for the instance of the DPL program; providing, to an execution engine for executing the DPL program, the state object and the prepared thread; and passing the message to the execution engine.

Thread-agile execution of dynamic programming language programs

Techniques are described herein that are capable of deep cloning (a.k.a. deep copying) objects using a binary format. A deep clone of a designated object includes references to other objects (and potentially copies of the other objects) included in the designated object. A binary representation of each object in an object graph is generated to provide a binary clone of the object graph. Objects created by a dynamic language engine are called dynamic language objects. Objects created by a host (e.g., that hosts the dynamic language engine) are called host objects. Each host object is associated with an intermediate representation thereof via a property bag that describes properties of that host object. Each intermediate representation is understandable by the dynamic language engine. A binary representation of each dynamic language object and each host object may be generated in accordance with the binary format to provide the binary clone.

Deep cloning of objects using binary format

Aspects of the subject matter described herein relate to serializing and de-serializing objects. In aspects, a serialization engine uses a grammar to serialize data into a binary representation. The serialization engine may call upon a host serialization engine to serialize embedded object that are not directly supported by the environment hosting the serialization engine. The serialization engine may encode the grammar used to serialize the data into the serialized data for use in de-serializing the data. After the object is serialized, the serialized data may be de-serialized when desired by using the grammar. The grammar is such that it causes embedded objects and relationships to be preserved in the serialized representation of the object.

Using grammar to serialize and de-serialize objects

At least one embodiment described herein relates to the selective capturing of script code stacks associated with exceptions thrown by script code. For unhandled exceptions, the script engine 1) captures the script code stack in a host-accessible manner in which a host that hosts the script engine may access the captured script code stack, 2) completes unwinding of the script stack, and 3) reports the captured script code stack to a host that hosts the script engine. For at least one of the handled exceptions thrown by the script code for which the script code itself handles the exception, the script code stack is not captured in the host-accessible manner. Also, the call stack property of an error object is populated at throw time, rather than creation time.

Capturing telemetry data by dynamic language engine

A script engine for a dynamic language can collect memory allocation information for dynamic objects created by the scripting engine and for dynamic objects created by the script engine host. A native interface can be exposed to a client comprising a software development tool. The software development tool can be a third-party tool. In response to a query, the script engine can take a snapshot of a garbage collector heap and return an object record for each dynamic object in the heap. The object information can include memory allocation information, object type and other information. Multiple snapshots can be taken and the delta between snapshots can be determined and sent to a requestor.

Memory usage data collection and analysis for dynamic objects

Systems and methods are described for passing a data item to and obtaining the data item from a scripting environment hosted by a host environment, wherein each environment uses a different representation of the data item. The host environment passes the data item to the scripting environment by passing a host environment representation of the data item that is hidden from developers of scripts to be executed by the scripting environment. This enables the original host environment representation of the data item to be preserved even after the data item has been passed to and from the scripting environment in the case where the scripting environment does not modify the data item, and also facilitates lazy conversion of the data item or avoidance of conversion entirely in the case where the scripting environment does not modify the data item.

Hidden representations for marshaling through hosted scripting environments

Methods are provided for thread-agile script execution. Thread-agile script execution may be carried out by receiving, in a message queue, a message for an instance of a script and determining whether the web browser has a stored state object for the instance of the script identified by the message. If the web browser has a stored state object for the script, thread-agile script execution may be carried out by retrieving the state object; preparing a thread available from a thread pool for execution of the instance of the script in dependence upon the state object and an execution context for the instance of the script; providing, to an execution engine for executing the script, the state object and the prepared thread; and passing the message to the execution engine.

Growing community of inventors

Redmond, WA, United States of America

Gaurav Seth