Patents
Literature
Hiro is an intelligent assistant for R&D personnel, combined with Patent DNA, to facilitate innovative research.
Hiro

106 results about "Managed code" patented technology

Managed code is computer program code that requires and will execute only under the management of a Common Language Infrastructure (CLI) Virtual Execution System (VES) virtual machine, e.g. .NET Core CoreFX, .NET Framework Common Language Runtime (CLR), or Mono. The term was coined by Microsoft.

Serialization for structured tracing in managed code

A system and method, useful in tracing program execution, for serializing data, such as an object data, into consistent, structured (e.g., XML) output. A serializer processes an object's data, and for each set of data, records the object's data in a structured (e.g., XML) format that reflects the object's current state. Nodes corresponding to fields and properties of the object are nested in the structure. Simple types define nodes with the current data value associated with the tag. More complex types including arrays, collections, dictionaries and exceptions are stored as individual members of a type, with any complex members further broken down into sub-nodes. Object data including custom collections, dictionaries, non-public fields and properties and properties with only get-accessor are serialized. The resulting output, such as in an XML formatted structure, is easy to read by humans, and is easily processed, such as for automated analysis purposes.
Owner:MICROSOFT TECH LICENSING LLC

Instant messaging communications channel for transporting data between objects executing within a managed code environment

A method, system, and apparatus for providing a communications channel for inter-object communication are provided. According to the method, a request may be received from a first object executing within a managed code environment to transmit data to a second object. In response thereto, an instant message (“IM”) including the data may be transmitted to an IM server computer. The IM may be forwarded to the managed code environment in which the second object is executing. The IM may then be received by the managed code environment, the data contained therein may be extracted, and the data may be presented to the second object. A reverse path may also be utilized for return communication between objects.
Owner:MICROSOFT TECH LICENSING LLC

Extensible architecture for auxiliary displays

Described is a system and method by which an auxiliary computing device having an auxiliary display platform that displays information corresponding to data that originated on the main computer system may be extended by a device manufacturer. Extended hardware is added to the device, such as a radio receiver and / or an audio decoder. The auxiliary display platform is layered and extensible at each layer, and includes an extensible hardware abstraction layer that is extensible to support extended hardware if needed, and a driver layer that is extensible by adding driver code for the extended hardware. A runtime layer is also extensible to support the extended hardware as needed, as are libraries, the auxiliary shell program and other managed code. The client API is also extensible to allow applications on the main computer system to communicate with extended hardware via the device runtime layer.
Owner:MICROSOFT TECH LICENSING LLC

Systems and methods for managing drivers in a computing system

Managed code, including applications, runtime, and driver, have a priori knowledge of the client's exact hardware configuration, just as the JIT compiler has a priori knowledge of the microprocessor type on the target computer system. At compile time, the compiler knows the effective version various system drivers, so that the compiler can emit an executable tuned for a particular driver version and target system.
Owner:MICROSOFT TECH LICENSING LLC

Systems and methods for employing tagged types in a dynamic runtime environment

The present invention relates to systems and methods that facilitate dynamic programming language execution in a managed code environment. A class component is provided that declares an inheritance hierarchy for one or more tagged values associated with a dynamic programming language. During execution of the tagged values, a rules component mitigates user-defined types from inheriting or deriving properties from the tagged values in order to support a type safe runtime environment. A bifurcated class tree is provided that defines non-tagged type elements on one side of the tree and tagged type element values on an alternate branch of the tree. The rules component analyzes runtime extensions that help to prevent data from one component of the tree deriving or inheriting properties from another component of the tree. The runtime extensions include such aspects as cast class extensions, test class extensions, and conversion class extensions for converting data types from one class subtype to another.
Owner:MICROSOFT TECH LICENSING LLC

Managing code when communicating using heirarchically-structured data

A description of the hierarchically-structured document is accessed and converted into an early-bound object having at least some of the same properties as the hierarchically-structured document, and having at least some of the methods that may be performed on the hierarchically-structured document. When a function call is placed to the early-bound object, the early-bound object causes the appropriate corresponding changes to be affected on the hierarchically-structured document while maintaining change tracking information for the document. This reduces the difficulty when drafting source code for a program that interfaces with hierarchically-structured documents that can have varying structures and may be governed by complex change tracking rules.
Owner:MICROSOFT TECH LICENSING LLC

Compiling executable code into a less-trusted address space

Unsafe application programs that implement managed code can be executed in a secure fashion. In particular, an operating system can be configured to execute an application program in user mode, but handle managed code compilation through a type-safe JIT compiler operating in kernel mode. The operating system can also designate a single memory location to be accessed through multiple address spaces with different permission sets. An application program operating in user mode can be executed in the read / execute address space, while the JIT compiler operates in a read / write address space. When encountering one or more pointers to intermediate language code, the application runtime can send one or more compilation requests to a kernel mode security component, which validates the requests. If validated, the JIT compiler will compile the requested intermediate language code, and the application program can access the compiled code from a shared memory heap.
Owner:MICROSOFT TECH LICENSING LLC

Accelerated Execution for Emulated Environments

The illustrative embodiments provide a computer implemented method, apparatus, and computer program product for accelerating execution of a program, written in an object oriented programming language, in an emulated environment. In response to receiving a request for an accelerated communications session from a guest virtual machine in the emulated environment, a native virtual machine is initiated external to the emulated environment but within the computing device hosting the emulated environment. Thereafter, an accelerated communications link is established between the guest virtual machine and the native virtual machine. The accelerated communications link enables a transfer of managed code between the guest virtual machine and the native virtual machine. The managed code is then executed by the native virtual machine.
Owner:IBM CORP

Declarative pinning

A system and method is provided for efficiently pinning references to the managed heap. The system and method allow for references to managed objects to be declared as pinned during a call to unmanaged code. The references are then reported as pinned to a garbage collector in response to invocation of a garbage collection service. The reference can be declared as pinned by a programmer within the source code or automatically invoked at run-time based on an unsafe condition. The garbage collection service will not move or relocate objects that are referenced by the active pinned local variables. If a garbage collection does not occur, the fact that the local variables are declared pinned is ignored.
Owner:MICROSOFT TECH LICENSING LLC

Unified Processor Architecture For Processing General and Graphics Workload

A processor comprising one or more control units, a plurality of first execution units, and one or more second execution units. Fetched instructions that conform to a processor instruction set are dispatched to the first execution units. Fetched instructions that conform to a second instruction set (different from the processor instruction set) are dispatched to the second execution units. The second execution units may be configured to performing graphics operations, or other specialized functions such as executing Java bytecode, managed code, video / audio processing operations, encryption / decryption operations etc. The second execution units may be configured to operate in a coprocessor-like fashion. A single control unit may handle the fetch, decode and scheduling for all the executions units. Alternatively, multiple control units may handle different subsets of the executions units.
Owner:GLOBALFOUNDRIES INC

Method and apparatus for providing instrumentation data to an instrumentation data source from within a managed code environment

A method and apparatus for providing instrumentation data to an instrumentation data source from within a managed code environment is provided. A decoupled provider is provided that executes partially in managed code and partially in unmanaged code. The decoupled provider facilitates communication with an instrumentation data source. The decoupled provider also dynamically registers schema for managed code objects to be instrumented at run-time. The decoupled provider also receives and processes requests from the instrumentation data source to retrieve instance data for managed code objects, to write properties on managed code objects, and to execute methods on managed code objects.
Owner:MICROSOFT TECH LICENSING LLC

History based rights computation for managed code

In the access control model of security, an access control matrix associates rights for operations on objects with subjects. An approach for assigning rights to code at run-time involves determining the run-time rights of a piece of code by examining the attributes of the pieces of code that have run (including their origins) and any explicit requests to augment rights. Thus, this approach relies on the execution history for security. This history based approach reduces the difficulties and the error-proneness of securing extensible software systems.
Owner:MICROSOFT TECH LICENSING LLC

Method and apparatus for accessing instrumentation data from within a managed code environment

An instrumentation client API is provided within a managed code runtime environment for accessing instrumentation data that resides outside of the managed code runtime environment. The instrumentation client API provides access to instrumentation data in a manner that is consistent with the classes and models provided by the runtime environment, raises exceptions in a manner that is compatible with the runtime environment, and is secure. The instrumentation client API wraps, or translates, calls to and from an instrumentation data source external to the runtime environment. The API interacts with an interface provided by the instrumentation data source to provide functionality and connectivity that is not otherwise provided by the instrumentation data source. The API also provides access to instrumentation data in a manner that is consistent with the models and classes provided by the runtime platform. The classes defined by the API return collections and exceptions in a way that is consistent with the managed code runtime platform.
Owner:MICROSOFT TECH LICENSING LLC

Techniques for managed code debugging

A system and method for facilitating cross-process access into a managed code process is useful in an embodiment of the invention for debugging managed code without perturbing the process being accessed or requiring the code under test to be running during debugging. A compiler according to an embodiment of the invention is used to produce mirror code wherein in-process pointers have been replaced with cross-process pointers in order to mirror the address space of the process under test to the address space of the mirror code process. In a further embodiment, the mirror code process is modified not only to allow but also to optimize the cross-process access.
Owner:MICROSOFT TECH LICENSING LLC

Centralized cell homing and load balancing in a base station controller

A base station controller (BSC) of a radio or wireless telecommunications network base station includes a director. A BSC includes multiple central processing units (CPUs), with each CPU running a call-processing application for one or more connections. The director is a logical entity that intercepts wireless call-setup signaling and assigns each corresponding connection to a CPU according to a centralized load-balancing algorithm. The centralized load-balancing algorithm distributes connections to less loaded CPUs to i) prevent individual CPUs from overloading, ii) utilize otherwise unused system resources, and iii) increase overall system performance. The director hosts cell components that manage code division multiple access (CDMA) downlink spreading codes for a base station, providing centralized allocation of spreading codes by the base station.
Owner:WSOU INVESTMENTS LLC +1

System and method for inducing asynchronous behavioral changes in a managed application process

A system and method for inducing asynchronous behavioral changes in a managed application process is presented. An application manager process is executed. A managed application process is executed. At least one application provided as object-oriented program code under the control of a managed code platform is executed. The managed application process logically communicates with the application manager process. One or more constructors corresponding to notifiable objects provided as object-oriented program code are identified. Each constructor keeps track of instantiated notifiable objects in a list in the managed application process. A change request is broadcast to the managed application process. The notifiable objects tracked by each identified constructor are iterated over to effect a behavioral change in the managed application process.
Owner:ORACLE INT CORP

Speech-related object model and interface in managed code system

InactiveUS20050171780A1Easy to implementEasily authored and implementedSpeech recognitionSpeech synthesisManaged codeSpeech sound
The present invention provides an object model that exposes speech-related functionality to applications that target a managed code environment. In one embodiment, the object model and associated interfaces are implemented consistently with other non-speech related interfaces supported across a platform.
Owner:MICROSOFT TECH LICENSING LLC

Method and system for periodically managing code modification report

InactiveCN104461671AEasy to count workloadProgram controlMemory systemsManagement toolManaged code
The invention discloses a method and system for periodically managing a code modification report. The method comprises the following steps: performing a periodic code executing step for starting a timing task; carrying out a modification record generating step for generating a code modification record according to a related code management tool, obtaining the modification records performed by an author on each branch in each code within a previous set time, and storing the modification records in a first format document; carrying out a format converting step for generating a format file for enabling a manager to look up quantized workload according to a modification record raw material; extracting useful data in the first format document, inputting the useful data in a second format document, and merging similar terms in a classification manner; performing a unified automatic submission step for submitting the second format documents generated by all staff in a set group within the previous set time to a set address. The method and system for periodically managing code modification report provided by the invention can be used for intelligently tracking, recording and summarizing codes modified by a programmer, so as to conveniently count the workload of the programmer.
Owner:WINGTECH COMM

Managing code-tracing data

A method of managing code-tracing data is described. The method comprises the steps of: receiving code-tracing data from an executing software component; adding the received code-tracing data to a log stored in temporary storage; detecting a property of the received code-tracing data; copying the log to non-volatile storage when the property matches a defined trigger property; and deleting contents of the log according to a caching policy when the property does not match a defined trigger property.
Owner:NCR CORP

System and method for storing and retrieving XML data encapsulated as an object in a database store

A system and method are provided for modeling structured, semi-structured, and unstructured data all within a single instance of a user defined type (UDT) within a database store. In particular, the XML data model is extended to fields of a UDT. As a result, the properties of the XML data model-such as document order and document structure-can be preserved within instances of a UDT. Moreover, code representing object behavior (i.e., methods that can be invoked on an object in managed code) can be added to the UDT to operate on an XML field, as well as non-XML fields of the UDT. This enables a framework for adding business logic to XML data. The content model of the XML data can be optionally described using XML schema documents associated with the XML fields of the UDT.
Owner:MICROSOFT CORP

Managing code samples in documentation

Documentation having code samples is managed. Documentation describing programming code for a software product is received. The documentation references a code sample having an associated test module for determining whether the code sample is valid. The code sample is tested by executing the associated test module to produce a test result indicating whether the code sample is valid. The documentation, code sample, and test result are stored. The documentation, code sample, and test result may be provided to a client adapted to display the code sample and test result to a user of the client. Invalid code samples in the documentation may be identified using the test modules and the invalid code samples may be replaced to make the code samples valid.
Owner:GOOGLE LLC

Garbage Collection Control in Managed Code

Controlling garbage collection operations. The method includes setting up garbage collection to collect objects that are no longer in use in a managed code environment. The method further includes receiving managed code input specifying a desired quantum within which it is desired that garbage collection not be performed. The method further includes performing a computing operation to determine the desired quantum can likely be met. The method further includes running memory operations within the quantum without running the initialized garbage collection.
Owner:MICROSOFT TECH LICENSING LLC

Method And System For Enabling Managed Code-Based Application Program To Access Graphics Processing Unit

One embodiment of the present invention sets forth a method for enabling an intermediate code-based application program to access a target graphics processing unit (GPU) in a parallel processing environment. The method includes the steps of compiling a source code of the intermediate code-based application program to an intermediate code, translating the intermediate code to a PTX instruction code, and translating the PTX instruction code to a machine code executable by the target graphics processing unit before delivering the machine code to the target GPU.
Owner:NVIDIA CORP

Systems, methods, and apparatus for automated code testing

Systems, apparatus, methods, and articles of manufacture provide for managing code deployment. In one example implementation, after packaging application code, a code deployment system defines a first container and a second container for a container-as-a-service (CaaS) service, based on the application code package. The example system then uses the CaaS service to automatically conduct a first container test of the first container, and, in parallel, to automatically conduct a second container test of the second container.
Owner:THE TRAVELERS INDEMNITY

System and method for consolidating middleware management

A computer readable medium stores a program for managing multiple types of middleware transport modules for accessing business logic. The computer readable medium includes a first starting code segment for starting a first middleware transport module of the multiple types of middleware transport modules as a main thread; a second starting code segment for starting a second middleware transport module as a slave thread; and a managing code segment for managing the main thread and the slave thread. The slave thread is managed in accordance with the managing of the main thread, and a functionality of the slave thread remains independent of a functionality of the main thread. Managing the slave thread may include shutting down the slave thread in response to shutting down the main thread.
Owner:SBC KNOWLEDGE VENTURES LP
Who we serve
  • R&D Engineer
  • R&D Manager
  • IP Professional
Why Patsnap Eureka
  • Industry Leading Data Capabilities
  • Powerful AI technology
  • Patent DNA Extraction
Social media
Patsnap Eureka Blog
Learn More
PatSnap group products