Microsoft Technology Licensing, LLC

Workman Nydegger

Microsoft Technology Learning, LLC

Stephen Harris Toub

John Joseph Duffy

Igor Ostrovsky

Mike Liddell

Huseyin Serkan Yildiz

Joseph E Hoag

Mads Torgersen

Jan Kotas

Dmitry Lomov

Joe Duffy

Eric Lynn Eilebrecht

David Charles Wrighton

Pranav Krishnamoorthy

Chunyan Song

Danny S Shih

Anders Hejlsberg

Matthew J Warren

Niklas Gustafsson

Jared Porter Parsons

Zlatko Michailov

Joshua Phillips

Julien Couvreur

Tim Harris

Stephane Delcroix

Michael John McLaughlin

Thomas A McDonald

Karen Ng

Lorianne Lamkin

Boby George

Daniela Cristina Manu

Henricus Johannes Maria Meijer

Jordi Mola

Dharma Kiritkumar Shukla

David L Detlefs

Vinod Grover

Timothy Lawrence Harris

Paul F Ringseth

Michael M Magruder

Martin Taillefer

Vance Palmer Morrison

Yosseff Levanoni

Martin Abadi

Charles David Callahan, Ii

Patrick Nelson

Juan Carlos Arevalo Baeza

Weirong Zhu

Brian M Grunkemeyer

Brian Robert Crawford

Margus Veanes

Thomas Lai

Lingli Zhang

Alexander Dadiomov

Del Myers

Gregg Bernard Miskelly

Scott A Thurlow

Edward George Essey

Dana D Groff

Gregory Bernard Miskelly

Michael L Chu

Emad A Omara

Sukhdeep S Sodhi

Kumar Gaurav Khanna

Tomas Matousek

Ramasamy Krishnaswamy

Evelyne Viegas

Lucian Wischik

Robert Eric Lippert

David M Fowler

Savas Parastatidis

Lukas Barton

Christopher William Dern

William Edwin Hiebert

Daniel James Moseley

Isadora Sophia Garcia Rodopoulos

Sayed Ibrahim Hashimi

Olli Ilari Saarikivi

Diana Milirud

Michael John Liddell

Melitta L G Andersen

Richard Steele Gibson

Clayton L Culver

Bill Messmer

Ian William James Halliday

Ian W J Halliday

Kayle K Hinkle, Iii

Lucian Jules Wishchik

Samer El Baghdady

Emad Ali

Dmitry I Lyalin

Damian Paul Edwards

Jose Rodrigo Perez Rodriguez

Christopher Sienkiewicz

Andrew Spenser Gocke

Andrey Noskov

Juraj Blaek

Martin Tomka

Laura Mitrache

Some embodiments automatically and proactively adjust network device configuration settings during network operation, based on correlations between device performance and device configuration. Correlations are computed using statistics routines or computed by a machine learning module. Some embodiments share adjusted configuration values via a cache, and some persist adjusted values through an application restart. In some embodiments, the cache is hierarchical and different kinds of reconfiguration data are shared at different levels. In some embodiments, the configuration value is shared only between application instances that have sufficiently similar contexts. Some embodiments detect a correlation loss and fall back to a known good configuration setting or a default configuration setting. Some embodiments optimize network internode communications by making dynamic adjustments which are not available from static configuration settings or from static configuration rules.

Dynamic network reconfiguration

Utilizing role types that extend underlying types. Within a program definition, a computer system identifies a statement assigning an object of an underlying type to a role type that extends the underlying type. The underlying type implements a first interface, and the role type implements a second interface. Based on the role type extending the underlying type, the computer system assigns the object of the underlying type to the role type. Based on assigning the object of the underlying type to the role type, the role type is usable to interact with the object of the underlying type using both the first interface and the second interface.

Runtime support for role types that extend underlying types

Techniques are described herein that are capable of constructing a finite automaton using regular expression derivatives to simulate behavior of a backtracking engine. The behavior indicates an order in which paths in an input regular expression are to be evaluated by the backtracking engine. The finite automaton is constructed to include a graph that includes a root node that represents the input regular expression. Regular expressions are derived such that each derived regular expression is a regular expression derivative of the input regular expression or of another derived regular expression. Priorities are assigned to alternations in the derived regular expressions to correspond to priorities indicated by the behavior. Nodes that represent the respective derived regular expressions and transitions between respective pairs of nodes are caused to be included in the graph. Priorities, which correspond to the order, are assigned to respective branches of the graph.

Finite automaton construction using regular expression derivatives to simulate behavior of a backtracking engine

Improved compilers recognize interception declarations in source code, and emit code that replaces invocations of specified artifacts with invocations of specified interceptors instead. Source generators proactively modify program behavior in arbitrary desired ways without introducing hidden security violations and without requiring edits by the program's developers. Interception declarations are visible in source code and development tools. In some cases, different invocations of a particular method at respective locations are intercepted by different replacement methods. Replacement methods have identical signatures, or are otherwise compatible. Some interceptors specify optional parameters. Method calls, field accesses, and property calls may be intercepted. Work to modify program behavior is moved in the program lifecycle from runtime to compile time, thus improving runtime performance and eliminating JIT compilation security risks.

Member invocation declarative interception

A single asynchronous enumerable object is generated that contains the data and methods needed to iterate through an enumerable asynchronously. The asynchronous enumerable object contains the code for traversing the enumerable one step at a time and the operations needed to suspend an iteration to await completion of an asynchronous operation and to resume the iteration upon completion of the asynchronous operation. The allocation of a single object to perform all of these tasks reduces the memory consumption needed to execute an asynchronous enumeration.

Compiler-generated asynchronous enumerable object

The present application discloses methods, systems, and computer program products for automatically generating source code implementing a regular expression. A regular expression that is defined within source code of an application project is identified. The source code uses a higher-level programming language. Based on identifying the regular expression, a source code implementation of the regular expression is automatically generated using the higher-level programming language, and the source code implementation of the regular expression is integrated into the application project. After integrating the source code implementation of the regular expression into the application project, the source code implementation of the regular expression is compiled into lower-level code and the lower-level code is emitted into an application executable when building the application project, or the source code implementation of the regular expression is interpreted when executing the application project.

Automatic generation of source code implementing a regular expression

A computing device including a processor configured to receive source code including a plurality of source code modules. The processor may generate executable code from the source code and assign two or more reload indicators to two or more executable code modules. The processor may execute the executable code. During execution of the executable code, the processor may receive a source code update and generate an executable code update from the source code and the source code update. The processor may apply the executable code update to the executable code to generate updated executable code. The processor may generate a reload ordering of two or more reload operations corresponding to the reload indicators. As specified by the reload ordering, the processor may perform the two or more reload operations at the two or more respective executable code modules. The processor may execute the updated executable code.

Reload ordering for executable code modules

An asynchronous method is implemented in a manner that reduces the amount of runtime overhead needed to execute the asynchronous method. The data elements needed to suspend an asynchronous method to await completion of an asynchronous operation, to resume the asynchronous method at a resumption point, and to provide a completion status of the caller of the asynchronous method are consolidated into one or two reusable objects. An asynchronous method may be associated with a distinct object pool of reusable objects. The size of a pool and the total size of all pools can be configured statically or dynamically based on runtime conditions.

Reduced memory consumption of compiler-transformed asynchronous methods

Hot reloading a running application with an unsaved source code change. A code change to a source code of a running software application that is associated with a project type is identified. The code change is stored within an in-memory editor buffer, and is uncommitted to any source code file. It is determined that the code change can be applied to the running software application using hot reload. Hot reload agent(s) associated with the project type are identified. Using the hot reload agent(s), the code change is communicated to an application runtime associated with the running software application. At least one process of the running software application invokes a new compiled code entity corresponding to the code change.

Hot reloading a running application with an unsaved source code change

Reuse of a thread-local return data structure to prevent a return data structure from being allocated every time asynchronous functions return. The system returns thread operation from the asynchronous function back to the caller function in a manner that the return data structure can be reused for future asynchronous function returns within that same thread. To do so, the system first accesses data that was generated by the asynchronous function in response to the caller function placing the function call to the asynchronous function. To determine if reuse is appropriate, the system determines that the caller function will use the return data structure as populated only once. If so, the system populates the reusable thread-local return data structure and returns that data structure to the caller.

Thread-local return structure for asynchronous state machine

Representing asynchronous functionality in intermediate code, and then having the runtime compiler, rather than the source code language compiler, declare the corresponding asynchronous state machine. This allows the size of the intermediate code to be smaller thereby facilitating more efficient delivery of the code to end users. Furthermore, the runtime compiler can now use its optimization capability to optimize performance of the asynchronous functionality specific to the actual environment in which the asynchronous work will operate.

Representing asynchronous state machine in intermediate code

Dynamically allocated thread storage in a computing device is disclosed. The dynamically allocated thread storage is configured to work with a process including two or more threads. Each thread includes a statically allocated thread-local slot configured to store a table. Each table is configured to include a table slot corresponding with a dynamically allocated thread-local value. A dynamically allocated thread-local instance corresponds with the table slot.

Dynamically allocated thread-local storage

Parallel tasks are created, and the tasks include a first task and a second task. Each task resolves a future. At least one of three possible continuations for each of the tasks is supplied. The three continuations include a success continuation, a cancellation continuation, and a failure continuation. A value is returned as the future of the first task upon a success continuation for the first task. The value from the first task is used in the second task to compute a second future. The cancellation continuation is supplied if the task is cancelled and the failure continuation is supplied if the task does not return a value and the task is not cancelled.

Composable and cancelable dataflow continuation passing

Described technologies support selectively tracing a process's execution, with some extra tracing done beyond the code the developer wanted traced, but with significantly reduced computational cost, by reducing the number of trace enablement and disablement operations. A trace controller uses a tracing disablement distance variable whose values indicate the computational distance from trace disablement. A distance variable modifier automatically moves the distance variable closer to a stop-tracing value as the process executes. A create task function is modified to include the setting of an indicator that a newly created task is to be traced if a current task or thread is being traced. An execute task function is modified to request the tracing of the newly created task when it is executed based on the indicator, thereby enabling selective tracing that operates across process boundaries and traces asynchronous code execution.

Selectively tracing portions of computer process execution

Growing community of inventors

Seattle, WA, United States of America

Stephen Harris Toub