Abstract: 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.

Abstract: 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.

Abstract: 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.

Abstract: 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.

Abstract: 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.

Abstract: 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.

Abstract: 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.

Abstract: 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 H 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.

Abstract: 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.

Abstract: 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.

Abstract: 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.

Abstract: 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.

Abstract: 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, versioned write locks are used with parallel nested transactions. When a transactional memory word changes from a write lock to a versioned write lock, an entry is made in a global versioned write lock map to store a pointer to a write log entry that the versioned write lock replaced. When the versioned write lock is encountered during transaction processing, the global versioned write lock map is consulted to translate the versioned write lock to the pointer to the write log entry.

Abstract: 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.

Abstract: 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.

Abstract: 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.

Abstract: 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.

Abstract: 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.

Abstract: 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.

Abstract: 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.