Microsoft Technology Licensing, LLC

Microsoft Corporation

Raja Krishnaswamy

Christopher Wellington Brumme

Gopala Krishna R Kakivaya

Jonathan C Hawkins

David S Mortenson

Patrick Henri Dussud

Michael M Magruder

James S Miller

Sean Edwin Trowbridge

Jeffrey M Cooperstein

Tarun Anand

Erik B Christensen

Charles W Kaufman

Anders Hejlsberg

David Bau

Brian LaMacchia

Lance Olson

Henry L Sanders

David S Ebbo

Julie D Bennett

Travis Muhlestein

Krzysztof J Cwalina

Seth Mitchell Demsey

Brian M Grunkemeyer

Shawn Patrick Burke

Christopher L Anderson

Stefan Harrington Pharies

Loren Kohnfelder

Yung-Shin Lin

Anthony J Moore

Frank V Peschel-Gallee

Erik B Olson

Yann Christensen

Fabio A Yeon

James H Hogg

Craig T Sinclair

Corina Eva Feuerstein

Adam Wade Smith

Shajan Dasan

Caleb L Doise

Alan Geoffrey Boshier

Radu Rares Palanca

Manish S Prabhu

John Grant Bennett

Gregory Darrell Fee

Mahesh Prakriya

Steven J Pratschner

David Owen Driver

Steven E Lucco

Jerry Jay Dunietz

Michael John Hillberg

Martyn S Lovell

Ketan K Dalal

Elliot H Omiya

Stephen C Rowe

Samuel Ng

Ales Holecek

Jesse Daniel Kaplan

Tassaduq Basu

Noel Richard Cross

Tarik Soulami

William G Evans

Brent Rector

James F Springfield

David L Detlefs

Yan Valerie Leshinsky

Stephen James Millet

Giovanni Moises Della-Libera

Nikhil Kothari

Scott David Guthrie

Akhilesh Kaza

Debi P Mishra

Christopher David Brown

Avner Y Aharoni

Beysim Sezgin

Mark A Alcazar

Luca Bolognese

Keith W Ballinger

Brian Keith Pepin

Mark T Anders

Jun Fang

Peter Alan Carlin

Madhusudhan Talluri

Susan M Warren

Alan C Shi

John M Hawkins

Peter F Sollich

Rudi Martin

Robert Michael Howard

Nicholas M Kramer

Manu Vasandani

Aaron Ross Goldfeder

Viresh Ramdatmisier

Nikhil Jain

Thottam Sriram

Kamaljit S Bath

Scott D Mosier

Chad W Royal

Aleksey V Tsingauz

Mark W Fussell

Data-aware orchestration with respect to a distributed system platform enables at least lifting and shifting of pre-existing applications and associated data without developer action. A volume of a local store is created automatically in response to a container comprising a user application that is non-native with respect to the distributed system platform. The volume is then exposed to the container for use by the application to save and retrieve data. The container and local store are co-located on a compute node providing at least high availability. The application and local store can be duplicated on one or more replicas providing reliability in case of a failure. Further, partitions can be created automatically in response to declarative specification.

Data-aware orchestration

The present invention extends to methods, systems, and computer program products for managing object lifetime in a cyclic graph. Embodiments of the invention include reclaiming allocated system resources, for example, from a graph of objects that mixes different resource reclamation techniques (such as reference counting and garbage collection). In response to determining that garbage collection is to be performed, references between GC objects and Ref. Counted objects are detected. A reference type (e.g., direct, indirect, standard, tracked, weakened, etc.) for any detected references is also determined. Garbage collection is performed to determine if any allocated system resources can be reclaimed. Garbage collection considers references and references types between GC objects and Ref. Counted objects when determining if objects are to be reclaimed.

Managing object lifetime in a cyclic graph

Various embodiments provide an ability to describe, independent of a programming language, one or more interfaces associated with an operating system. Alternately or additionally, a compiler associated with a specific programming language can be configured to map the independent interface description(s) to the specific programming language. In some embodiments, an application can be configured to programmatically determine one or more interfaces of the operating system.

Runtime system

A system and method for facilitating execution of multiple assemblies in a framework, in which the assemblies use a component external to the framework, is provided. A runtime manager may retrieve metadata from each of the assemblies, and selectively insert the metadata into a unified types object, so that metadata corresponding to equivalent type definitions is shared. When each assembly is executed, the combined metadata may be used to invoke or otherwise interact with the external component.

Unified metadata for external components

Embodiments are directed to dynamically adapting metadata for use with a native data encoding and to efficiently modifying object model type references. In one scenario, a computer system instantiates a metadata reader over an object model description to access various portions of metadata in the object model description. The metadata reader is configured to read native metadata, where native metadata is metadata represented in an encoding that is expected by the metadata reader. The metadata reader determines that the accessed metadata is encoded in a non-native encoding and then determines which metadata modifications are to be performed to transform the non-native encoding into a native encoding. The computer system then dynamically adapts the metadata of the object model from a non-native encoding to a native encoding according to the determined modifications. As such, the object model is readable by a native runtime.

Efficiently providing multiple metadata representations of the same type

A hosted pre-compilation system is described herein that provides a way to enable ahead-of-time compilation for managed code running inside a host. The host triggers ahead-of-time compilation at application runtime, after any configuration settings are available. The host can choose which modules to compile, when to compile them, and where to persist the generated images. Upon detecting a module load, the host can trigger pre-compilation, provide the loader an existing pre-compiled image of the module, or do nothing. The runtime/platform validates the integrity of any host-supplied pre-compiled image and provides application programming interfaces (APIs) to inform the host when an image becomes invalid and fails to load. The platform also provides APIs to let the host trigger compilation of binaries at any time relevant to the host, and to generate the images either synchronously or in a background process.

Pre-compiling hosted managed code

A library management system may compare contracts between programming libraries to identify unions, intersections, and differences between libraries. The management system may have a contract analyzer that may remove the contract definition from an existing library to form a library contract. The library contract may be managed as a first class item within a programming environment, and may be used as a reference for comparing existing and new versions of the library. The library management system may create reference libraries for programmers to write applications using two or more intersecting libraries, among other uses.

Library conformity checker

Assertions for elevated privilege associated with transparent code may be ignored, prohibited, or modified.

Transparent code

Various technologies and techniques are disclosed that use code access security for providing runtime accessibility checks. A request is received from a first program to access at least one private member of a second program at runtime. If the first program has a greater than or equal security context than the second program, then the first program is granted access to the at least one private member of the second program. This code access security check can be provided in a framework environment that is responsible for managing programs that are from unknown or untrusted sources.

Using code access security for runtime accessibility checks

Various technologies and techniques are disclosed for providing host control of partial trust accessibility. A framework allows libraries to be identified as partial trust callers allowed to indicate that the libraries are allowed to be called from partially trusted code by default. The framework allows libraries to be identified as partial trust callers enabled to indicate the libraries could be called from partially trusted code, but not by default. A hosting application is notified that a particular library has been loaded. If the particular library has been identified as partial trust callers allowed, then a determination is received from the hosting application on whether to remove or keep partial trust accessibility for the particular library. If the particular library has been identified as partial trust callers enabled, then a determination is received from the hosting application on whether or not to enable partial trust accessibility for the particular library.

Host control of partial trust accessibility

Mechanisms that allow frameworks significant flexibility in varying the library of common base classes in a manner that better suits the domain of applications served by the framework. Instead of providing the base class library, the runtime provides a data contract for the data structure of each base class. The frameworks can then define each base class in a custom way so long as the data contract is honored. Thus, for example, the framework may provide custom framework-specific methods and/or properties as is appropriate for the framework. Another framework might define the base classes in a different way.

Flexible base class library

User assemblies can be created by a compiler that can handle more than one type definition during execution. Local copies are created for respective authoritative types in a code library, and the local copies are marked with a local type identifier. An authoritative type identifier (e.g., a globally unique identifier (GUID)) is copied from the authoritative type to the local type, and functions and properties associated with the local type are also copied from the authoritative type. Authoritative types are resolved for requested types when a local assembly references a local type from a compiled user assembly. The local type can be identified by a local type identifier, and an authoritative type can be retrieved from the code library that has a same authoritative type identifier as the requested type. A local copy of the retrieved authoritative type can be copied to the local assembly under compilation. The compiler can then emit user assemblies that comprise merely local types.

Handling multiple definition of types

Growing community of inventors

Redmond, WA, United States of America

Raja Krishnaswamy