Abstract: A log unit provides a shared log for recording updates on data objects. Garbage collection is performed locally and in-place by the log unit. In a marking portion of the garbage collection process, the log unit identifies and marks log entries that record supersedable updates. In a deallocation portion of the process, the log unit deallocates at least portions of the marked log entries that contain supersedable updates.

Abstract: Techniques for implementing dynamic timeout-based fault detection in a distributed system are provided. In one set of embodiments, a node of the distributed system can set a timeout interval to a minimum value and transmit poll messages to other nodes in the distributed system. The node can further wait for acknowledgement messages from all of the other nodes, where the acknowledgement messages are responsive to the poll messages, and can check whether it has received the acknowledgement messages from all of the other nodes within the timeout interval. If the node has failed to receive an acknowledgement message from at least one of the other nodes within the timeout interval and if the timeout interval is less than a maximum value, the node can increment the timeout interval by a delta value and can repeat the setting, the transmitting, the waiting, and the checking steps.

Abstract: A shared log in a distributed system provides for direct access to the most current data state of an object stored in the shared log. Directly accessing the data state of an object obviates the need for a client to replay all the transactions stored in the shared log made on the object.

Abstract: In accordance with disclosed embodiments, a shared log system includes a sequencer that receives a source object and a snapshot time reference, where the source object is used to generate data for a destination object. The sequencer uses the snapshot time to determine whether the data state of the source object is current with respect to the snapshot time, to assess correctness of the generated data relative to the snapshot time.

Abstract: In accordance with disclosed embodiments, a shared log system includes a sequencer to verify transactions that comprise a source object and one or more members of the source object (source data objects), a target object and one or more members of the target object (target data objects), and a snapshot time reference. The sequencer verifies transaction using the snapshot time to determine whether the data states of the source data objects at the time of the snapshot time represent their most current data state in a shared log.

Abstract: Embodiments are disclosed to mitigate the meltdown vulnerability by selectively using page table isolation. Page table isolation is enabled for 64-bit applications, so that unprivileged areas in the kernel address space cannot be accessed in user mode due to speculative execution by the processor. On the other hand, page table isolation is disabled for 32-bit applications thereby providing mapping into unprivileged areas in the kernel address space. However, speculative execution is limited to a 32-bit address space in a 32-bit application, and s access to unprivileged areas in the kernel address space can be inhibited.

Abstract: The disclosure provides an approach for transferring a packet from a source client to a destination application across a network. The approach generally includes writing an identifier to the packet by a switch, transferring the packet to a distributed log, logging a copy of the packet at the distributed log, and analyzing the packet for misplaced requests. The approach further includes, transmitting the packet from the distributed log to the destination, intercepting the packet by a shim layer and comparing the identifier to a counter maintained by the shim layer, and forwarding the packet to the destination application.

Abstract: Embodiments of the present disclosure relate to techniques for maintaining a state of a distributed system. In particular, certain embodiments relate to identifying a function. Some embodiments relate to, upon determining that the function comprises an annotation indicating that the function is capable of modifying the state of the distributed system, transforming the function to allow the function to generate updates to a state machine.

Abstract: A heater comprising: (a) a film; (b) one or more coverings that extends along one or more sides of the film; and (c) one or more power application portions that apply power to the film so that the film heats up; wherein the film is a graphite film.

Abstract: A telescoping access cannula comprising: an outer tube; an inner tube carried by the outer tube, the inner tube being coaxial with the outer tube and longitudinally movable relative to the outer tube; and a rotatable member carried by the outer tube and connected to the inner tube, wherein rotation of the rotatable member causes longitudinal movement of the inner tube relative to the outer tube.

Abstract: Embodiments are disclosed to mitigate the meltdown vulnerability by selectively using page table isolation. Page table isolation is enabled for 64-bit applications, so that unprivileged areas in the kernel address space cannot be accessed in user mode due to speculative execution by the processor. On the other hand, page table isolation is disabled for 32-bit applications thereby providing mapping into unprivileged areas in the kernel address space. However, speculative execution is limited to a 32-bit address space in a 32-bit application, and s access to unprivileged areas in the kernel address space can be inhibited.

Abstract: The present disclosure addresses the meltdown vulnerability resulting from speculative execution in a multi-core processing system. The operating system (OS) can be loaded for execution on one of several processing cores (OS core), while an application can be loaded for execution on another of the processing cores (application core). The OS core uses process page tables that map the entire kernel address space to physical memory. Conversely, the application core uses pages tables that map only a portion of the kernel address space to physical memory.

Abstract: In accordance with embodiments of the present disclosure, a compiler can compile source code to produce binary code that includes address shifting code inserted with memory operations. The address shifting code can shift addresses of memory operations that access locations in the kernel address space into address locations in the user space, thus avoiding speculative access into the kernel address space.

Abstract: In accordance with embodiments of the present disclosure, a binary translator can perform address shifting on the binary code of an executing application. Address shifting serves to shift the addresses of memory operations that can access locations in the kernel address space into address locations in the user space, thus avoiding speculative access into the kernel address space.

Abstract: A system and method are disclosed for executing a component of a design in a hardware engine. The component is compiled to include an interface that supports an ‘open_loop(n)’ function which, when invoked, requests that the hardware engine run for a specified number of steps before communicating with other hardware or software engines via a runtime system. After the compiled hardware component is transferred to the hardware engine, the hardware engine runs for the specified number of steps unless and until it encounters a system function, such as a ‘display(s)’ function, in the code of the component that requires the runtime system to intervene. The hardware engine pauses awaiting the completion of the system function and continues its execution. The ‘open_loop(n)’ operation of the hardware engine permits components in hardware engines to run at a speed close to the native speed of the target programmable hardware fabric.

Abstract: A method for implementing a distributed hardware system includes retrieving a hardware design described in a hardware description language, where the hardware design includes a plurality of components. The method further includes, for each component of the hardware design, sending the component to a hardware compiler and to one of a plurality of software engines, where the hardware compiler compiles the component to run in one of a plurality of hardware engines and the one software engine simulates the component while the hardware compiler compiles the component for the one hardware engine, and upon completion of the compilation of the component, sending the compiled component to one of the hardware engines to be executed by the one hardware engine and monitoring communication so that the one hardware engine can interact with other components in other hardware engines or software engines.

Abstract: A method for implementing a distributed hardware system includes retrieving a hardware design described in a hardware description language, where the hardware design includes a plurality of modules. The method includes sending modules of the design to software engines, where the runtime maintains for each module being simulated a queue for update and evaluation events. Update events on the queue are those that update stateful objects in the module and cause evaluation events to be enqueued onto the module's queue while evaluation events are those that update stateless objects in the module and cause update events to be enqueued onto the module's queue. Having a queue for each module permits the runtime to manage module simulations so that the executions of each module run concurrently with each other. This leads to faster executions of the modules and less complex communications between modules during execution.

Abstract: A system and method are disclosed for executing a hardware component of a design in a hardware engine, where the component includes a pre-compiled library component. The hardware component is compiled to include an interface that supports a ‘forward( )’ function which, when invoked, requests that the hardware engine running the hardware component run such that interactions between the library component and the hardware component occur without communicating with the runtime system because interactions between the library component and the hardware component are handled locally by the hardware engine and not the runtime system. Handling the library component without the runtime system intervening allows the library component to run at a speed that is close to the native speed of the target re-programmable hardware fabric. In addition, library components targeted to the specific reprogrammable hardware fabric are available to the design without compilation.

Abstract: A system and method for executing a hardware component of a design is disclosed. The system and method execute hardware components that are constructed with a ‘display(s)’ function that permits the hardware component to display values internal to the hardware component while the component is executing on a hardware engine. The values are displayed on a user output interface, such as a user terminal, supported by a runtime system controlling the execution of the hardware engine and thus allows the user to have a view into the executing hardware that would be otherwise unavailable. This view permits the user to debug the component executing on the hardware engine.

Abstract: Exemplary methods, apparatuses, and systems include a distributed memory agent within a first node intercepting an operating system request to open a file from an application running on the first node. The request includes a file identifier, which the distributed memory agent transmits to a remote memory manager. The distributed memory agent receives, from the remote memory manager, a memory location within a second node for the file identifier and information to establish a remote direct memory access channel between the first node and the second node. In response to the request to open the file, the distributed memory agent establishes the remote direct memory access channel between the first node and the second node. The remote direct memory access channel allows the first node to read directly from or write directly to the memory location within the second node while bypassing an operating system of the second node.