Patent application number | Description | Published |
20110078691 | STRUCTURED TASK HIERARCHY FOR A PARALLEL RUNTIME - The present invention extends to methods, systems, and computer program products for a structured task hierarchy for a parallel runtime. The parallel execution runtime environment permits flexible spawning and attachment of tasks to one another to form a task hierarchy. Parent tasks can be prevented from completing until any attached child sub-tasks complete. Exceptions can be aggregated in an exception array such that any aggregated exceptions for a task are available when the task completes. A shield mode is provided to prevent tasks from attaching to another task as child tasks. | 03-31-2011 |
20110126204 | SCALABLE THREAD LOCKING WITH CUSTOMIZABLE SPINNING - Embodiments described herein are directed to dynamically controlling the number of spins for a selected processing thread among a plurality of processing threads. A computer system tracks both the number of waiting processing threads and each thread's turn, wherein a selected thread's turn comprises the total number of waiting processing threads after the selected thread's arrival at the processor. Next, the computer system determines, based the selected thread's turn, the number of spins that are to occur before the selected thread checks for an available thread lock. The computer system also, based on the selected thread's turn, changes the number of spins, such that the number of spins for the selected thread is a function of the number of waiting processing threads and processors in the computer system. | 05-26-2011 |
20110161610 | COMPILER-ENFORCED AGENT ACCESS RESTRICTION - A compiler that enforces, at compile time, domain data access permissions and/or agent data access permissions on at least one agent to be created within a domain. The compiler identifies domain data of a domain to be created, and an agent to be created within the domain at runtime. The domain access permissions of the agent are also identified. As part of compilation of an expression of an agent, a reference to the domain data is identified. Then, the compiler evaluates an operation that the reference to the domain data would impose on the domain data upon evaluating the expression at runtime. The compiler then determines whether or not the operation is in violation of the domain access permissions of the agent with respect to the identified domain data. Agent data access may also be evaluated depending on whether the access occurs by a function or a method. | 06-30-2011 |
20110185358 | PARALLEL QUERY ENGINE WITH DYNAMIC NUMBER OF WORKERS - Partitioning query execution work of a sequence including a plurality of elements. A method includes a worker core requesting work from a work queue. In response, the worker core receives a task from the work queue. The task is a replicable sequence-processing task including two distinct steps: scheduling a copy of the task on the scheduler queue and processing a sequence. The worker core processes the task by: creating a replica of the task and placing the replica of the task on the work queue, and beginning processing the sequence. The acts are repeated for one or more additional worker cores, where receiving a task from the work queue is performed by receiving one or more replicas of tasks placed on the task queue by earlier performances of creating a replica of the task and placing the replica of the task on the work queue by a different worker core. | 07-28-2011 |
20110191775 | ARRAY-BASED THREAD COUNTDOWN - The forking of thread operations. At runtime, a task is identified as being divided into multiple subtasks to be accomplished by multiple threads (i.e., forked threads). In order to be able to verify when the forked threads have completed their task, multiple counter memory locations are set up and updated as forked threads complete. The multiple counter memory locations are evaluated in the aggregate to determine whether all of the forked threads are completed. Once the forked threads are determined to be completed, a join operation may be performed. Rather than a single memory location, multiple memory locations are used to account for thread completion. This reduces risk of thread contention. | 08-04-2011 |
20110219380 | MARSHALING RESULTS OF NESTED TASKS - The present invention extends to methods, systems, and computer program products for marshaling results of nested tasks. Unwrap methods are used to reduce the level of task nesting and insure that appropriate results are marshaled between tasks. A proxy task is used to represent the aggregate asynchronous operation of a wrapping task and a wrapped task. The proxy task has a completion state that is at least indicative of the completion state of the aggregate asynchronous operation. The completion state of the aggregate asynchronous operation is determined and set from one or more of the completion state of the wrapping task and the wrapped task. The completion state of the proxy task can be conveyed to calling logic to indicate the completion state of the aggregate asynchronous operation to the calling logic. | 09-08-2011 |
20140108438 | REFERENCE ATTRIBUTE ANNOTATION SIGNIFYING NO EXTERNAL REFERENCE - The annotation of a returned reference from an executable component to signify that there are no external references to the particular object graph referenced by the returned reference. If either 1) there are no input arguments to the executable component or 2) each input argument is either immutable or represents an object graph that has no external mutable references pointing into the object graph, and no internal mutable references that reference external objects, the particular attribute is assigned to the returned reference. Accordingly, if the returned reference is writable (as determined by evaluating the declaration code or the call code for the executable component), the returned reference is free to have whatever access permissions assigned to it, and may also be assigned to an isolated memory location, though such assignments will cause the returned reference to lose the particular attribute. | 04-17-2014 |
20140189699 | SCALABLE THREAD LOCKING WITH CUSTOMIZABLE SPINNING - Embodiments described herein are directed to dynamically controlling the number of spins for a selected processing thread among a plurality of processing threads. A computer system tracks both the number of waiting processing threads and each thread's turn, wherein a selected thread's turn comprises the total number of waiting processing threads after the selected thread's arrival at the processor. Next, the computer system determines, based the selected thread's turn, the number of spins that are to occur before the selected thread checks for an available thread lock. The computer system also, based on the selected thread's turn, changes the number of spins, such that the number of spins for the selected thread is a function of the number of waiting processing threads and processors in the computer system. | 07-03-2014 |
20140195563 | OBJECT GRAPH PARTIAL IMMUTABILITY AND ISOLATION ENFORCEMENT - The type definition of particular types such that different portions of the corresponding object graph may have different permissions assigned to those portions during instantiation. This allows structured permissions to be applied to instantiations of the object graphs of those defined types, allowing fine grained control over what access permissions are enforced against which portions of the object graph. In some embodiments, different instantiations of the object graph may apply permissions differently. | 07-10-2014 |
20140195632 | IMMUTABLE SHARABLE ZERO-COPY DATA AND STREAMING - The environment and use of an immutable buffer. A computing entity acquires data or generates data and populates the data into the buffer, after which the buffer is classified as immutable. The classification protects the data populated within the immutable buffer from changing during the lifetime of the immutable buffer, and also protects the immutable buffer from having its physical address changed during the lifetime of the immutable buffer. As different computing entities consume data from the immutable buffer, they do so through views provided by a view providing entity. The immutable buffer architecture may also be used for streaming data in which each component of the streaming data uses an immutable buffer. Accordingly, different computing entities may view the immutable data differently without having to actually copy the data. | 07-10-2014 |
20140195862 | SOFTWARE SYSTEMS BY MINIMIZING ERROR RECOVERY LOGIC - Handing errors in program execution. The method includes identifying a set including a plurality of explicitly identified failure conditions. The method further includes determining that one or more of the explicitly identified failure conditions has occurred. As a result, the method further includes halting a predetermined first execution scope of computing, and notifying another scope of computing of the failure condition. An alternative embodiment may be practiced in a computing environment, and includes a method handing errors. The method includes identifying a set including a plurality of explicitly identified failure conditions. The method further includes determining that an error condition has occurred that is not in the set including a plurality of explicitly identified failure conditions. As a result, the method further includes halting a predetermined first execution scope of computing, and notifying another scope of computing of the failure condition. | 07-10-2014 |
20140196008 | IMMUTABLE OBJECT TYPES - A language extension that advances safety in system programming in that an entire type may be declared to be immutable in the case in which all instances of that type are immutable. The immutable type declaration automatically causes any instances of that type to be treated as immutable, and automatically causes all directly or indirectly reachable members (e.g., fields, methods, properties) of the instance to also be treated as immutable. Furthermore, any construction time reference that allows for field assignment of the instance is not permitted to survive beyond the point at which the instance becomes accessible to its creator. Accordingly, this instance, and any other instance of that same type, will be immutable from the very time of construction. The ability to classify all such instances as immutable is beneficial as the immutable characteristic permits actions that normally would not be allowed due to resource access safety. | 07-10-2014 |
20140196015 | DECLARATION OF LIFETIME OF RESOURCE REFERENCE - A language extension that advances safety in system programming by specifying a lifetime of a reference that represents a resource. In accordance with the language extension, the lifetime references a particular scope in a manner that the compiler generates computer-executable instructions that enforce the lifetime of the reference to be a function of (e.g., no longer than) the lifetime of the particular scope. Accordingly, the resource lifetime may be specified in advance to have a particular scope. This helps in performing resource management as typical managed language programs can allow resources to exist indefinitely. Furthermore, because the resources have a defined finite lifetime, they might be more conveniently allocated on a stack, instead of on a heap, for much more efficient processing. | 07-10-2014 |
20140282448 | OPERATING SYSTEM SUPPORT FOR CONTRACTS - A front-end compiler compiles source code into intermediate code, that may later be compiled into binary code. The source code defines an execution scope and includes a contract. When a contract is encountered at runtime of an execution scope, further execution of that execution scope is conditioned on whether a predicate associated with the contract is true. The front-end compiler operates so as to preserve the contract so that the contract continues to be semantically structured such that the predicate may be removed from the intermediate language code. The contract may thus continue to be understood by semantic analysis of the contract. Thus, the predicate may be understood by static analysis tools that operate on the intermediate code. | 09-18-2014 |
20150324175 | RESOURCE ACCESS SAFETY THROUGH IMMUTABLE OBJECT TYPES - A language extension that advances safety in system programming in that an entire type may be declared to be immutable in the case in which all instances of that type are immutable. The immutable type declaration automatically causes any instances of that type to be treated as immutable, and automatically causes all directly or indirectly reachable members (e.g., fields, methods, properties) of the instance to also be treated as immutable. Furthermore, any construction time reference that allows for field assignment of the instance is not permitted to survive beyond the point at which the instance becomes accessible to its creator. Accordingly, this instance, and any other instance of that same type, will be immutable from the very time of construction. The ability to classify all such instances as immutable is beneficial as the immutable characteristic permits actions that normally would not be allowed due to resource access safety. | 11-12-2015 |
Patent application number | Description | Published |
20080281786 | PRODUCER/CONSUMER OPTIMIZATION - Systems and methods facilitate efficient data processing in a computer environment. Data producers and consumers are considered in aggregate rather than in isolation. In one instance, interaction between data producers and consumers is improved by integrating producers and consumers. Optimization can subsequently be performed over the combination to produce synergistic results. | 11-13-2008 |
20100250507 | ENUMERATION OF A CONCURRENT DATA STRUCTURE - An enumerable concurrent data structure referred to as a concurrent bag is provided. The concurrent bag is accessible by concurrent threads and includes a set of local lists configured as a linked list and a dictionary. The dictionary includes an entry for each local list that identifies the thread that created the local list and the location of the local list. Each local list includes a set of data elements configured as a linked list. A global lock on the concurrent bag and local locks on each local list allow operations that involve enumeration to be performed on the concurrent bag. | 09-30-2010 |
20100262801 | TYPE SYSTEM SUPPORT FOR MEMORY ISOLATION PERMISSIONS - An object reference is tagged with an isolation permission modifier. At least two permissions can be included, and in an example three permissions are included. In implementing the permissions, type modifiers for controlling access to type members through references pointing at an object are defined. One of the type modifiers is associated with each occurrence of a type name. Each of the of type modifiers defines a different access permission to restrict operations on the object to which the reference points. | 10-14-2010 |
20100275191 | CONCURRENT MUTATION OF ISOLATED OBJECT GRAPHS - Fine-grained parallelism within isolated object graphs is used to provide safe concurrent operations within the isolated object graphs. One example provides an abstraction labeled IsolatedObjectGraph that encapsulates at least one object graph, but often two or more object graphs, rooted by an instance of a type member. By encapsulating the object graph, no references from outside of the object graph are allowed to objects inside of the object graph. Also, the encapsulated object graph does not contain references to objects outside of the graphs. The isolated object graphs provide for safe data parallel operations, including safe data parallel mutations such as for each loops. In an example, the ability to isolate the object graph is provided through type permissions. | 10-28-2010 |
20110289503 | EXTENSIBLE TASK SCHEDULER - A parallel execution runtime allows tasks to be executed concurrently in a runtime environment. The parallel execution runtime delegates the implementation of task queuing, dispatch, and thread management to one or more plug-in schedulers in a runtime environment of a computer system. The plug-in schedulers may be provided by user code or other suitable sources and include interfaces that operate in conjunction with the runtime. The runtime tracks the schedulers and maintains control of all aspects of the execution of tasks from user code including task initialization, task status, task waiting, task cancellation, task continuations, and task exception handling. | 11-24-2011 |
20110321059 | STACK OVERFLOW PREVENTION IN PARALLEL EXECUTION RUNTIME - A parallel execution runtime prevents stack overflow by maintaining an inline counter for each thread executing tasks of a process. Each time that the runtime determines that inline execution of a task is desired on a thread, the runtime determines whether the inline counter for the corresponding thread indicates that stack overflow may occur. If not, the runtime increments the inline counter for the thread and allows the task to be executed inline. If the inline counter indicates a risk of stack overflow, then the runtime performs additional one or more checks using a previous stack pointer of the stack (i.e., a lowest known safe watermark), the current stack pointer, and memory boundaries of the stack. If the risk of stack overflow remains after all checks have been performed, the runtime prevents inline execution of the task. | 12-29-2011 |
20130018860 | PARALLEL NESTED TRANSACTIONS IN TRANSACTIONAL MEMORY - Various technologies and techniques are disclosed for supporting parallel nested transactions in a transactional memory system. Multiple closed nested transactions are created for a single parent transaction, and the closed nested transactions are executed concurrently as parallel nested transactions. Various techniques are used to ensure effects of the parallel nested transactions are hidden from other transactions outside the parent transaction until the parent transaction commits. For example, retry is allowed to work correctly with parallel nested transactions. When a transaction that is a parallel nested transaction or a child transaction of the parallel nested transaction executes a retry, a read set of the transaction is registered for the retry. When a decision is made to propagate the retry past a parallel nested transaction parent of the transaction, keeping the read set registered and making the read set part of a parent read set. | 01-17-2013 |