WO2017131780A1

WO2017131780A1 - Identifying object modifications

Info

Publication number: WO2017131780A1
Application number: PCT/US2016/015815
Authority: WO
Inventors: Izzat EL HAJJ; Alexander MERRITT; Gerd ZELLWEGER; Dejan S. Milojicic
Original assignee: Hewlett Packard Enterprise Development Lp
Priority date: 2016-01-29
Filing date: 2016-01-29
Publication date: 2017-08-03

Abstract

Example implementations relate to identifying object modifications. In one example, identifying object modifications can employ a non-transitory processor readable medium including instructions to mark an entry in a pointer bounds table invalid, where the entry is associated with an object, attempt retrieval of pointer bounds associated with the entry in the pointer bounds table, and identify the object as modified when the pointer bounds are not retrieved.

Description

IDENTIFYING OBJECT MODIFICATIONS

Background

[0001] Computing devices such as laptop computers, desktop computers, tablets, servers, and/or other types of computing devices may include a virtual memory system and/or a versioned object-store, in a virtual memory system, each process of the computing device may be provided a virtual address space (VAS). A virtual memory system organizes memory in units called "pages." Versioned object-stores may allow clients to capture a particular state of a certain object, group of objects, or the entire object store at a given point in time. Such versioned object-stores may allow clients to revert back to a particular captured state.

Brief Description of the Drawings

[0002] Figure 1 is a block diagram of an example of a device suitable for identifying object modifications according to the disclosure.

[0003] Figure 2 illustrates an example of a non-transitory processor readable medium according to the disclosure.

[0004] Figure 3 is a flow chart illustrating an example of a method of identifying object modifications according to the disclosure. [0005] Figure 4 is a flow chart illustrating an example of a method of identifying object modifications according to the disclosure.

[0006] Figure 5 is a flow chart illustrating an example of a method of identifying object modifications according to the disclosure.

[0007] Figure 6 is a flow chart illustrating an example of a method of identifying object modifications according to the disclosure.

Detailed Description

[0008] Versioned object-stores may allow clients to capture a particular state of a certain object, group of objects, or the entire object store at a given point in time. Such versioned object-stores may allow clients to revert back to a particular captured state. Some approaches to capturing a particular state of a versioned object store may not detect and/or may not accurately detect modifications to an object that is less than a particular size. For instance, some approaches may not be capable of perceiving changes to sub-page sized objects. As a result, a particular state associated with the modification to the object may not be captured. Further, some approaches may not be capable of reverting back to a particular state corresponding to and/or including a modification to a sub-page size object is made.

[0009] Accordingly, examples of the disclosure relate to identifying object modifications. As used herein, an object refers to variables, data structures, functions, and/or other information stored at a particular location in memory. As used herein, object modifications refer to a creation, modification, and/or deletion of an object, in an example, identifying object modifications can employ a non-transitory processor readable medium including instructions to mark an entry in a pointer bounds table invalid, where the entry is associated with an object, attempt retrieval of pointer bounds associated with the entry in the pointer bounds table, and identify the object as modified when the pointer bounds are not retrieved. Desirably, readily identifying object modifications can promote versioning of objects such as sub-page sized objects, in contrast to other approaches (e.g., those relying on a page table) that may not be able to identify modifications to and/or version sub-page sized objects. [0010] Figure 1 is a block diagram of an example of a device suitable for identifying object modifications according to the disclosure. As illustrated in Figure 1 the device 1 10 can include a processor 120, a physical memory 130, a non-volatile memory 132, and a non-transitory processor readable medium 140, among other possible components to promote identifying object modifications.

[0011] The device 1 10 can be a computing device, such as a server, a desktop computer, a laptop computer, a tablet, a smartwatch, and/or a smartphone, among other suitable devices to promote identifying object modifications. The processor 120 can refer to a central processing unit (CPU), graphics processing unit (GPU), an application specific integrated circuit (ASIC), and/or another types.

[0012] As illustrated in Figure 1 , the processor can include default (i.e., existing) registers 134 and metadata registers 136 (e.g., bounds registers). In various examples, the metadata registers 136 can represent and/or include hardware register extensions of the default registers 134. For instance, the metadata registers 136 can provide hardware register extensions to hold metadata (e.g., bounds in metadata registers 136) and maintain the association of the metadata with its corresponding data (e.g., pointers in default registers 134) when it is copied or modified without the additional pressure on the default registers 134. By providing (implicit or explicit) association between the default registers 134 and the metadata registers 136, the metadata and/or calling convention of these registers can remain the same. However, metadata being held at the metadata registers 136 may be used for different purposes by the processor 120 than metadata held at the default registers 134.

[0013] As used herein, a register such as a metadata register can include a general purpose or integer register (that is used for storing data and addresses and is regarded as a combined data/address register) and other registers, such as a user- accessible register, a data register, an address register, a condition register, a floating point register, a constant register, a vector register, a special purpose register (including an instruction register), a model-specific register, a control and status register, etc. in various examples, integer registers can form the metadata registers 136 however the disclosure is not so limited and instead any type or a combination of types of registers may be employed to promote identifying object modifications, as described herein. [0014] As mentioned, the metadata registers 136 can hold metadata associated with data in the default registers 134. in various examples, when a default register 134 contain a memory address (e.g., a pointer) the metadata registers 136 may be used to specify the range of memory addresses that can be accessed (load/store) using the default registers 134. The address in the default registers 134 can be outside the bounds specified in a corresponding metadata register 204. These bounds may be checked at the time of memory access such as a load operation, among other possibilities. Each memory address range consists of a lower bound (i.e. beginning address) and an upper bound (i.e., ending address).

[0015] A pointer bounds table such as those stored in registers and/or in memory can include a given number of bits (not shown). For instance, the registers such as the metadata registers 136 can include a pointer bounds table having a present bit or a modified bit, among other bits.

[0016] The registers can store pointer bounds tables and/or act as caches for a pointer bounds table. A pointer bounds table can include entries corresponding to sub- page sized objects and/or objects that have a size greater than a page. However, in various, examples, it is noted that a pointer bounds table can include an entry with pointer bounds of a sub-page sized object.

[0017] The physical memory 130 can refer to dynamic random access memory (DRAM), static random access memory (SRAM), non-volatile random access memory (NVRAM), phase change memory, and/or another suitable form of physical memory. The physical memory 130 can store processor executable instructions and data. The physical memory 130 can be separate and distinct from the non-volatile memory 132 and/or can be formed of at least in part of the non-volatile memory 132, among other possibilities.

[0018] The non-volatile memory 132 can refer to memory that does not depend upon power to store information such as metadata and/or data. Examples of nonvolatile memory can include solid state media such as flash memory, electrically erasable programmable read-only memory (EEPROM), phase change random access memory (PCRAM), magnetic memory such as a hard disk, resistive memory such as memristors, and/or a solid state drive (SSD), etc., as well as other types of machine- readable media.

[0019] The non-transitory processor readable medium 140, as detailed with respect to Figure 2, can include instructions, which when executed by the processor 120 or other processor to cause the processor to implement aspects of the examples described herein. For example, the non-transitory processor readable medium 140 may include virtual memory system instructions 142 such as object-oriented virtual memory instructions. The virtual memory system instructions 142 can abstract the physical memory 130 of the device 1 10 from a process 150 running on the device 1 10. For example, each process running on the device can be provided with a respective virtual address space. The respective virtual address spaces can be sized according to various constraints of the virtual memory system instructions 142, among other possibilities, in some examples, each process can utilize virtual address space in a manner that the process may not be aware of (e.g., aware of a size of) the physical memory 130 included in the device 1 10.

[0020] in operation, the process 150 executes on the device 110. That is, a process (e.g., a virtual machine) refers to instructions and/or data that can exist within a virtual address space and are executable by a processor to complete a task. For example, a database program running on the device 1 10 may be comprised of a number of processes. A process can run under control of an operating system and/or other type of controller such as a hypervisor.

[0021] As mentioned, the virtual memory system instructions 142 can include and/or form a plurality of virtual address spaces. The virtual memory system

instructions can organize virtual memory in units called "pages." Each page can be referenced by traversing a mapping table, which points to pages present in virtual memory. Each mapping table can be associated with objects (i.e., memory objects). As mentioned, in various examples, modifications to sub-page sized objects can be identified.

[0022] Figure 2 illustrates an example of a non-transitory processor readable medium 240 according to the disclosure. As mentioned, the non-transitory processor readable medium 240 includes instructions executable by a processor to perform a number of functions described herein.

[0023] The non-transitory processor readable medium 240 can be internal and/or external to the device (e.g., the device can include non-transitory processor readable medium and/or have access to an external non-transitory processor readable medium). The instructions (e.g., machine-readable instructions (MR!)) can include instructions stored on processor-readable medium (PRM) to implement a particular function. The set of MRI can be executable by a processor (e.g., processor 120 described with respect of Figure 1 ). The non-transitory processor readable medium 240 can be coupled to the device in a wired and/or wireless manner. For example, the non- transitory processor readable medium 240 can be an internal memory, a portable memory, a portable disk, and/or a memory associated with another resource (e.g., enabling MRI to be transferred and/or executed across a network such as the Internet).

[0024] Non-transitory processor readable medium 240 can include volatile and/or non-volatile memory. Volatile memory can include memory that depends upon power to store information, such as various types of DRAM among others. Non-volatile memory can include memory that does not depend upon power to store information.

[0025] As illustrated in Figure 2, the non-transitory processor readable medium 240 can include instructions such as mark instructions 246, retrieve instructions 248, and identify instructions 249. Such instructions can promote identifying object modifications, as described herein.

[0026] The mark instructions 246 can mark an entry in a pointer bounds table as invalid. In various examples, the mark instructions can include instructions to alter a state of a bit. For example, a present bit associated with the entry in a pointer bounds table can be deleted (i.e., cleared). However the disclosure is not so limited. Rather, in some examples, the mark instructions can mark a modified bit (i.e., a dirty bit) associated with an entry as modified. As used herein, a modified bit associated with an entry is separate and distinct from a present bit associated with the entry.

[0027] Each entry in the pointer bounds table is associated with an object such as a sub-page sized. That is, the entry includes information about the object such a size, location (e.g., an address or other indication of a location in memory), a pointer (e.g., a hardware pointer) to the object, and/or other information about the object, in some examples, the mark instructions 246 can mark an entry invalid in response to an access request to an object (e.g., a sub-page sized object) associated with the entry.

[0028] Pointer bounds can include metadata that specifies bounds for a pointer in a register. For instance, when a pointer is used to reference memory, a processor can compute a range of addresses that are to be accessed by an instruction and can compare those addresses against the bounds in a metadata register or other type of register to ensure that the memory locations accessed by any of the instructions are entirely within those bounds. Any attempt to access a memory location outside the bounds is prevented and in such a case, the processor signals an exception to allow the software program to handle this condition. In some examples, an address translation function can be employed to translate an address where a pointer is stored to the address where metadata is to be stored in the memory such that the metadata can be loaded or stored into metadata registers.

[0029] The retrieve instructions 248 can, in various examples, attempt retrieval of pointer bounds associated with the entry (e.g., the entry marked invalid) in the pointer bounds table. Retrieval can be attempted through execution of a call, command, and/or other type of instruction, in various examples, the identify instructions 249 can identify the object as modified, as described herein, when the pointer bounds are not retrieved.

[0030] Notably, in some examples, an object can be a sub-page sized object (i.e., an object having a size comparatively smaller than a particular size of a page). In such examples, the instructions can identify the sub-page sized object as modified when the pointer bounds are not retrieved, in contrast to other approaches (e.g., those relying on a page table) that may not be able to identify modifications to sub-page sized objects.

[0031] The non-transitory processor readable medium 240 can include

instructions to provide a notification to a user when the object is identified as modified. A notification can be communicated via a graphical user interface to a user, among other possibilities.

[0032] in some examples, the instructions can include instructions to identify an object as unmodified when the point bounds are retrieved. In this manner, at least some objects of a plurality of objects may be unmodified at a given time. [0033] The instructions can include instructions to retrieve object bounds and/or pointer bounds of an object in response to identifying the object as modified. For example, object bounds can be retrieved to facilitate subsequent retrieval of pointer bounds. The object bounds and/or pointer bounds can be retrieved from a storage location other than a pointer bounds table, however, in some examples the object bounds and/or the pointer bounds can be retrieved from a pointer bounds table, in various examples, the instructions can include instructions to write to the modified object using the retrieved pointer bounds, as described herein.

[0034] In some examples, the instructions can include instructions to preserve a version of an object. For instance, an object can be preserved through storage of a copy of an object (e.g., storing a copy of the object prior to writing to the object).

Examples of versioning and/or preserving a version of an object are described herein.

[0035] Figure 3 is a flow chart illustrating an example of a method of identifying object modifications according to the disclosure. As shown at 366, the method 365 can include storing information including pointer bounds of an object to form an entry in a pointer bounds table. For example, the method 365 can include storing metadata that represents a beginning address and an ending address of an object in a pointer bounds table. In some examples, the method 365 can include storing information including respective pointer bounds of a plurality of objects to form a plurality of entries in the pointer bounds table.

[0036] As shown at 367, the method 365 can include marking the entry invalid in the pointer bounds table, as described herein. In some examples, the method 365 can include marking each entry of a plurality of entries in a pointer bounds table invalid.

[0037] The method 365 can include attempting to retrieve pointer bounds of an object, as shown at 368. For example, the method can include attempting to retrieve pointer bounds of an entry marked invalid at 367. As shown at 369 the method 365 can include identifying the object as modified when the pointer bounds are not retrieved, as described herein.

[0038] In some examples, the method 365 can include taking a snapshot. For example, a snapshot of a plurality of objects can be taken in response to identifying at least one of the objects as modified, as described herein. A snapshot can be taken as described herein with respect to Figure 6.

[0039] Figure 4 is a flow chart illustrating an example of a method of identifying object modifications according to the disclosure. The method 475 can be employed through execution of instructions such as those described herein.

[0040] As shown at 476-1 the method 475 can include execution of instructions, such as those described herein, to store bounds of a pointer (e.g., pointer "X") in a pointer bounds table. As mentioned, the pointer bounds refer to metadata that represents a beginning address and an ending address of an object.

[0041] The method as shown at 476-2 can mark the entry in the pointer bounds table as invalid. As mentioned, marking an entry invalid can include deleting a present bit associated with the entry, among other possibilities. Deleting a present bit can cause subsequent attempts to write to the object to be intercepted. That is, the method 475 can include attempting to retrieve the pointer bounds of the pointer (e.g., pointer "X"), as shown at 476-3. However, due to marking the entry in the pointer bounds table invalid at 476-2 such attempts to retrieve the pointer bounds of the pointer can result in return of an interrupt. For instance, the method 475 can determine at 476-4 whether an interrupt such as an invalid bound directory interrupt is received. When an invalid bound directory interrupt is received in response to attempting to retrieve the pointer bounds the method 475 can proceed to 476-5 and mark the pointer bounds entry as valid.

[0042] The method can proceed to 476-6 and an object (associated with the pointer bounds) can be marked as modified. An object can be marked as modified by changing a modified bit to a modified state indicative that the object is modified, among other possibilities.

[0043] The method can proceed to 476-7 and mark the interrupt (e.g., an invalid bound directory interrupt) as handled. An interrupt can be marked as handled by clearing an interrupt status and/or other processor specific management operation such those effected by an interrupt controller driver and/or other type of driver, among other possibilities. [0044] In response to marking the interrupt as handled, the method 475 can proceed to 476-8 and retrieve pointer bounds (i.e., bounds) of the pointer (e.g., pointer "X") and proceed to 476-9. Similarly, when an invalid bound directory interrupt is not received in response to attempting to retrieve the pointer bounds the method 475 can proceed to 476-9. The method 475 can include writing to the object associated with the pointer bounds as shown at 476-9. For example, the method can write to a memory buffer storing the object.

[0045] Figure 5 is a flow chart illustrating an example of a method of identifying object modifications according to the disclosure. The method 580 can be employed through execution of instructions such as those described herein. At 581 -1 the method 580 can include execution of instructions, such as those described herein, to mark an entry in a pointer bounds table as invalid, as described herein.

[0046] At 581-2 the method 580 can attempt to retrieve pointer bounds of a pointer (e.g., pointer "X"), as described herein. At 581 -3 the method 580 can receive an invalid bound directory interrupt, among other possible interrupts. That is, the invalid bound directory interrupt can be received in response to attempt to retrieve the pointer bounds of the pointer (e.g., pointer "X").

[0047] At 581-4 the method 580 can mark the entry as valid, as described herein. At 581-5, the method 580 can read object bounds. At 581 -6 the method 580 can copy an object associated with the pointer bounds to preserve a current version of the object. Put another way, the object can be copied and stored elsewhere in advance of writing to the object. Desirably, the method 580 can enable storing a plurality of versions of objects and/or tracking writes to objects.

[0048] At 581 -7 the method 580 can mark the interrupt (e.g., the invalid bound directory interrupt) as handled, as described herein. The method 580 can proceed to 581-8 and retrieve pointer bounds of the pointer (e.g., from a bounds table). In response to retrieving the pointer bounds at 581-8, the method can write to the object associated with the pointer bounds, as shown at 581 -9. While Figure 5, describes tracking writes to and versioning of a particular object the disclosure is not so limited. Rather, writes to and/or versions of a plurality of objects can be tracked, for example, as described herein with respect to Figure 6. [0049] Figure 6 is a flow chart illustrating an example of a method of identifying object modifications according to the disclosure. The method 690 can be employed through execution of instructions such as those described herein. At 691-1 the method 690 can include execution of instructions to mark all entries invalid in a pointer bound table. For example, each respective present bit associated with the entries in the pointer bounds table can be deleted, among other possibilities.

[0050] in response to marking all entries invalid in the pointer table, a

determination to take a snapshot of objects associated with the entries in the pointer bounds table can be made as shown at 691-2. The determination to take a snapshot can be based on an amount of time elapsed from a previous snapshot (e.g., taking a snapshot when a threshold amount of time has passed), based on system activity (e.g., a read and/or write request attempt to an object, and/or based on a user input (e.g., a request to take a snapshot, among other possibilities. For example, when a snapshot is taken in response to a write request to an object the snapshot can capture each object (e.g., information included in each object) in advance of writing to the object, in such an example, the snapshot can correspond to a particular version an object and/or a plurality of objects.

[0051] in response to determining to take a snapshot, the method can proceed to 691 -2 and find all modified objects by walking the pointer bounds table. In some examples, the method can permit a write to an object following the snapshot. In such examples, the object is modified by the write to the object.

[0052] in various examples, the method can find all modified objects (those that have been written to following a prior version and/or snapshot) by walking through a pointer bounds table in response to identifying a write to an at least one object of the objects. A write to an object can be identified as described herein (e.g., as described herein with respect to Figure 4). Walking the pointer bounds table can include sequentialiy accessing entries in the pointer bounds table to identify an entry among the entries in the pointer bounds table that is modified. Depending upon a desired implementation, some or all entries can be "walked" to identify an entry among the entries in the pointer bounds table that is modified. In some examples, two or more entries in the pointer bounds table can be identified as modified by walking the pointer bounds table. That is, depending upon a total number of writes to entries in a pointer bounds table a total number of entries identified as modified can vary.

[0053] The method can proceed to 691 -4 and copy all modified objects. For example, an object associated with an entry that is identified as modified at 691-3 can be copied. In this manner, each respective object associated with a plurality of entries that are modified can be copied. The method can proceed to 691-5 and store object copies from 691-4 together with unmodified objects as new version and/or a snapshot of the objects at a given time.

[0054] In response to determining to not take a snapshot, the method can proceed to 691 -6 and continue execution, for instance, to retrieve pointer bounds of the pointer, as described herein. It is noted that some or all of 691-1 to 691-6 can be repeated any number of times to form a plurality of versions and/or snapshots of a plurality of objects.

[0055] As used herein, "logic" is an alternative or additional processing resource to perform a particular action and/or function, etc., described herein, which includes hardware, e.g., various forms of transistor logic, ASICs, etc., as opposed to computer executable instructions, e.g., software firmware, etc., stored in memory and executable by a processor. As used herein, "a" or "a number of something can refer to one or more such things. When an element is referred to as being "on," "connected to", "coupled to", or "coupled with" another element, it can be directly on, connected, or coupled with the other element or intervening elements may be present.

[0056] Since many examples can be made without departing from the spirit and scope of the system and method of the disclosure, this specification merely sets forth some of the many possible example configurations and implementations, in the disclosure, reference is made to the accompanying drawings that form a part hereof, and in which is shown by way of illustration how a number of examples of the disclosure can be practiced. These examples are described in sufficient detail to enable those of ordinary skill in the art to practice the examples of this disclosure, and it is to be understood that other examples can be used and that process, electrical, and/or structural changes can be made without departing from the scope of the disclosure. [0057] The figures herein follow a numbering convention in which the first digit corresponds to the drawing figure number and the remaining digits identify an element or component in the drawing. Elements shown in the various figures herein can be added, exchanged, and/or eliminated so as to provide a number of additional examples of the disclosure. In addition, the proportion and the relative scale of the elements provided in the figures are intended to illustrate the examples of the disclosure, and should not be taken in a limiting sense.

Claims

What is claimed:

1. A non-transitory processor readable medium including instructions to identify an object as modified, wherein the instructions when executed by a processor cause the processor to:

mark an entry in a pointer bounds table invalid, wherein the entry is associated with an object;

attempt retrieval of pointer bounds associated with the entry in the pointer bounds table; and

identify the object as modified when the pointer bounds are not retrieved.

2. The medium of claim 1 , wherein instructions to mark include instructions to alter a state of a bit.

3. The medium of claim 2, wherein the instructions to alter the state of the bit include instructions to delete a present bit associated with the entry.

4 The medium of claim 1 , wherein the pointer bounds comprise metadata that represents a beginning address and an ending address of the object.

5. The medium of claim 1 , wherein the instructions include instructions to mark the entry in the pointer bounds table invalid in response to an access request to the object.

6. The medium of claim 1 , including instructions to identify the object as unmodified when the pointer bounds are retrieved.

7. The medium of claim 1 , wherein the object is a sub-page sized object, and wherein the instructions include instructions to identify the sub-page sized object as modified when the pointer bounds are not retrieved.

8. A device comprising: an object-oriented virtual memory system including a sub-page sized object; a pointer bounds table including an entry with pointer bounds of the sub-page sized object; and

a non-transitory processor readable medium including instructions executable by the processor to:

mark the entry in the pointer bounds table invalid;

attempt retrieval of the pointer bounds of the sub-page sized object; and identify the sub-page sized object as modified when the pointer bounds are not retrieved.

9. The device of claim 8, wherein the instructions to mark the entry include instructions to mark a modified bit associated with the entry as modified, and wherein the modified bit is separate and distinct from a present bit associated with the entry.

10. The device of claim 8, including instructions to retrieve object bounds and pointer bounds of the sub-page sized object in response to identifying the sub-page sized object as modified and write to the modified sub-page sized object using the retrieved pointer bounds.

11. The device of claim 8, including instructions to preserve a version of the sub- page sized object.

12. A method comprising:

storing information including pointer bounds of an object to form an entry in a pointer bounds table;

marking the entry invalid in the pointer bounds table;

attempting to retrieve the pointer bounds of the object; and

identify the object as modified when the pointer bounds are not retrieved.

13. The method of claim 12, wherein storing includes storing information including respective pointer bounds of a plurality of objects to form a plurality of entries in the pointer bounds table.

14. The method of claim 13, including marking each entry of the plurality of entries in the pointer bounds table invalid.

15. The method of claim 14, including taking a snapshot of the plurality of objects in response to identifying at least one of the objects as modified.