CN101030135A - Method and device for storing C++ object in shared memory - Google Patents

Abstract

The present invention relates to a method and device for storing C++ objects in a shared memory. The method includes A. setting up a section of shared memory for a process that refreshes or applies for the creation of a shared memory for the first time, and maps the address of the shared memory to the process On a certain virtual address of the process space; B. the process accesses the shared memory through the virtual address, and stores the virtual address in the shared memory, and defines the virtual address as the original virtual address; C. C++ Objects and/or concatenated C++ objects are stored in shared memory. The device includes: a load or refresh unit, a shared memory storage unit and an object access unit. The invention solves the problem that the cross-process interactive access to the C++ object in the shared memory cannot be realized in the prior art.

Description

A method and device for storing C++ objects in shared memory

technical field

The invention relates to an operating system, in particular to a method and device for storing C++ objects in a shared memory.

Background technique

The shared memory is a feature provided by various operating systems such as UNIX. In C/C++ language, shmget and shmat (different operating systems may provide different API functions) return the address mapped to the process space. In this way, the shared memory can be operated like an ordinary memory space. In addition, the shared memory is mainly used for sharing data among multiple processes, and is a way of inter-process communication (IPC), allowing one or more processes to communicate through memory that simultaneously appears in their virtual address spaces. Because data does not need to be copied between client and server, shared memory is the fastest form of IPC.

Each process that uses shared memory must connect it to virtual memory through a system call. The pages of the virtual memory appear in the page table of each process. At this time, the process will create a new virtual memory management structure (vm_area_struct) to describe the shared memory. A process can determine where this shared memory resides in its virtual address space. Therefore, in different processes, the location of the shared memory mapping may be different. The new vm_area_struct structure will be placed in the vm_area_struct linked list pointed to by the shared memory descriptor (shmid_ds). Connect them through the pointer of the previous structure pointer (vm_next_shared) and the pointer of the rear structure pointer (vm_prev_shared). That is to say, the same segment of shared memory on a host has different addresses mapped to the process space for different processes running on the host.

All processes accessing the shared memory must access the same semaphore, and the security of the data stored in the shared memory is guaranteed through the semaphore.

At present, the methods for storing C++ objects in shared memory in the prior art are mainly realized through the following methods.

Please refer to Figure 1, which is a schematic diagram of an existing storage of C++ objects in shared memory. The principle of its implementation is: a group of identical objects (struct A) are sequentially stored in shared memory, and each object (struct A ) occupy the same space in shared memory.

It can be seen from the technical solution disclosed above that in this method, for the same segment of shared memory, the addresses mapped to different processes are different. That is to say, this method directly stores similar structures, but cannot store real structures containing C++ pointer properties. Even if a structure containing pointer properties is saved, when another process refers to the pointer properties of the object, it will also Cause pointer illegal access.

Please also refer to Figure 2, which is another schematic diagram of storing C++ objects in shared memory. The principle of its implementation is as follows: first, access objects stored in shared memory through index arrays (for example, struct A, B, C. ..), and there can be multiple index arrays (such as struct Idx), and each member of the index array is also a struct. Wherein, the struct Idx includes: object type, number, offset to the object (such as struct A, B, C...) and a search key. The struct Idx can use multiple algorithms (such as binary search, bubble search, etc.) to quickly access the data that is really concerned (struct A, B, C...). The objects (struct A, B, C...) are stored sequentially in the shared memory, which is the data that the user really cares about, and the occupied space of each object in the shared memory may be different.

Although this scheme is more advanced than method one, that is, the association between objects can be realized by designing the structure well. However, when different processes access data in the shared memory, they all need to access the objects stored in the shared memory through information such as offset and number in the index array, and the implementation is relatively complicated. It can be seen that this technical solution has basically the same disadvantages as the above-mentioned method 1, that is, the stored object (structure) cannot include pointer attributes (or array pointer attributes) pointing to other objects stored in the shared memory, because the pointer points to The value is meaningful only in the process. Therefore, even if an object including pointer attributes (or array pointer attributes) is stored, another process will cause illegal access when referencing the object's pointer attributes (or array pointer attributes). . That is, real C++ objects stored in shared memory cannot be transparently accessed between different processes.

Contents of the invention

The technical problem solved by the present invention is to provide a method and device for storing C++ objects in shared memory, so as to solve the problem that cross-process interactive access to C++ objects and/or cascaded C++ objects in shared memory cannot be realized in the prior art question.

In order to solve the above problems, the present invention provides a method for storing C++ objects in shared memory, said method comprising steps:

A. Set up a section of shared memory for refreshing or applying for the process of creating shared memory for the first time, and map the address of the shared memory to a certain virtual address of the process space of the process;

B. The process accesses the shared memory through a virtual address, stores the virtual address in the shared memory, and defines the virtual address as an original virtual address;

C. Store C++ objects and/or concatenated C++ objects in shared memory.

The method further includes: the client process accesses the C++ object and/or the cascaded C++ object stored in the shared memory by overloading the member reference operator of the C++ class.

The address of accessing a C++ object is: the sum of the difference between the pointer value and the virtual address of the shared memory mapped to the process where the visitor is located minus the original virtual address.

In step B, the process of storing the virtual address in the shared memory is specifically: storing the mapped virtual address for accessing the shared memory at a certain fixed location in the shared memory.

In step C, the C++ object and/or the concatenated C++ object are respectively stored in the shared memory in the manner of linking pointers.

The C++ object and/or the cascaded C++ object are respectively stored in the shared memory through pointer connection through the data loading or refreshing process.

The stored C++ objects and/or cascaded C++ objects may be continuous or discontinuous, and the space occupied by each stored object depends on whether the object includes an array pointer attribute and the number of array pointers.

In addition, the present invention also provides a device for storing C++ objects in shared memory, said device comprising: a load or refresh unit and a shared memory storage unit, wherein,

The loading or refreshing unit is used to set a section of shared memory for the process of refreshing or applying for the creation of the shared memory for the first time, and map the address of the shared memory to a certain virtual address of the process space of the process, through the virtual address accessing shared memory, and storing the virtual address in the shared memory storage unit;

The shared memory storage unit is connected to the load or refresh unit and is used to store C++ objects and/or cascaded C++ objects.

The device also includes:

The object access unit is used to access the C++ object and/or the cascaded C++ object in the shared memory storage unit by overloading the member reference operator of the C++ class.

Compared with the prior art, the present invention has the following beneficial effects: the present invention stores real C++ objects in the shared memory, and can put common, basic C++ objects and/or cascaded C++ objects in the application into the shared memory, All processes that need to use this object are like accessing C++ objects and/or cascaded C++ objects created in their own processes, which reduces the difficulty of application development and shortens the development cycle when implementing large-scale OOP applications with C++ ; Especially when multiple identical applications or service processes are running on the host, the use of the physical memory of the host is reduced; the technical solution of the present invention applies to the application of the database class, and the shared and frequently accessed dictionary parameters are put into the shared memory , reduce the access pressure on the database and speed up the access speed.

Description of drawings

Fig. 1 is a schematic diagram of storing C++ objects in shared memory in the prior art;

Fig. 2 is another schematic diagram of storing C++ objects in shared memory in the prior art;

Fig. 3 is the flowchart of the method for storing C++ object in shared memory of the present invention;

Fig. 4 is an embodiment of the method for storing C++ objects in shared memory according to the present invention;

Fig. 5 is another embodiment of the method for storing C++ objects in shared memory according to the present invention;

Fig. 6 is a schematic diagram of a device for storing C++ objects in shared memory according to the present invention;

Fig. 7 is an embodiment of the device for storing C++ objects in shared memory according to the present invention.

Detailed ways

The core of the present invention is that the operating system first sets the shared memory required by the process for the process running on the host, and the definition of the shared memory is a memory area reserved by the kernel for the purpose of exchanging information between multiple processes (segment), if the permissions are set properly, each process that wants to access the memory can map it to its own private address space, if a process updates the data in the segment, then other processes will see the update immediately, by Segments created by one process can also be read and written by another process. And map the address of the shared memory to a virtual address of the process space, the process that stores the C++ object and/or the cascaded C++ object to the shared memory accesses the set shared memory through the virtual address; at the same time, the process will The virtual address is stored in the set shared memory, and the address stored in the shared memory is defined as the original virtual address; by overloading the member reference method of C++ (for example: the member reference operator of the C++ class) to realize other processes to store in Transparent access to C++ objects in this shared memory. That is to say, all processes that want to use this object are like accessing a newly created C++ object in their own process, especially when using C++ to implement large-scale OOP applications, it reduces the difficulty of application development and shortens the development cycle.

The present invention will be further described below in conjunction with the accompanying drawings.

Please refer to FIG. 3 , which is a flow chart of the method for storing C++ objects in shared memory according to the present invention. The method comprises the steps of:

Step S11: setting the shared memory required by the process for refreshing or first applying for creating the shared memory, and mapping the address of the shared memory to a certain virtual address of the process space of the process;

Step S12: The process accesses the shared memory through a virtual address, stores the virtual address in the shared memory, and defines the virtual address as an original virtual address;

Step S13: storing the C++ object and/or the concatenated C++ object in the shared memory.

In the technical solution of the present invention, the process running on the host first applies to the operating system for the required shared memory, and the operating system allocates the corresponding shared memory resource for it, and maps it to a virtual address where its own process space is located. , the process accesses the applied shared memory by the virtual address; meanwhile, the process stores the virtual address in the applied shared memory, and the address stored in the shared memory is defined as the original virtual address; by overloading C++ The member reference method (that is, the member reference operator of the C++ class) realizes the transparent access of other processes to the C++ object stored in the shared memory. That is to say, the present invention accesses the same section of shared memory through the virtual address mapped in its own process space for the running process, and the original virtual address is stored in a fixed position in the shared memory, and for different processes, it can correctly Obtain the original virtual address; then load the C++ object and/or cascaded C++ object in the shared memory, wherein the C++ object includes a pointer or pointer array member attribute, and the pointer points to other objects stored in the shared memory C++ objects and/or cascaded C++ objects, each C++ object and/or cascaded C++ objects are connected through pointers; the process accesses the shared memory through the virtual address mapped to its own address space, and accesses the shared memory by accessing the shared memory. C++ objects and/or concatenated C++ objects in that shared memory. Please also refer to FIG. 4 for its specific implementation process.

As shown in Figure 4, it is an embodiment of the storage method of the C++ object in the shared memory of the present invention, and its realization principle is:

The first step is to determine the original virtual address in the shared memory. When the data loading process loads the C++ object into the shared memory, it first needs to map the shared memory to an address in the process space. It is defined as the original virtual address, and the address is stored in a fixed location in the shared memory. When other processes access objects from the shared memory, through the overloading mechanism of C++, the member reference operator (ie operator['.', '->']) of the C++ class in the shared memory is overloaded to realize the C++ semantics Object access on . The principle of the overloaded access is mainly: the address of the access object is equal to the sum of the difference between the pointer value and the shared memory address mapped by the process where the visitor is located minus the original virtual address. The formula is: object address=pointer value+(shared memory address mapped by the process where the visitor is located-original virtual address).

The second step is to access the object A stored in the shared memory through one or more index arrays. The index array generally includes: the size of the accessed object, multiple stored object struct Idx, and the like. In other words, each member of the index array is also a struct, and each member includes: a pointer to object A, and a search key, which can quickly access the real concern through various algorithms (such as binary search, bubble search, etc.) data (say object A). Algorithms such as the binary search and the bubble search are already known to those skilled in the art, and will not be repeated here.

The third step is to store class A objects through index arrays, which is a method of sequentially storing a class of C++ objects. The space occupied by each object can be the same or different, depending on whether the object contains an array pointer attribute and the individuality of the array pointer. number. The number of pointers in the array pointer determines the storage space occupied by the class object, and the larger the number, the larger the occupied space.

In the fourth step, for the storage organization structure of an object of C++ in the shared memory, the storage of all its attributes in the shared memory is continuous, which is the same as the storage in the application process. Wherein, the properties of the object may include pointer properties or array pointer properties, the type of which is any C++ type, including basic types and types defined by the application itself. As shown in the figure: attribute 1 of class A object is int, attribute 2 is char[20], attribute 3 is class c, attribute 4 is Void** (the Void** is a pointer to a pointer), attribute n for int etc.

The fifth step describes the class B object pointed to by the member pointer Void* of the array pointer attribute of the class A object. The storage method of a single class B object is similar to the storage method of the class A object, and will not be described in detail here.

The above-mentioned process of storing C++ objects is recursive from the third step to the fifth step, and its end condition is an object that does not contain an array pointer attribute, that is, it will not access other objects through this object.

As can be seen from the above implementation process, the method for storing real C++ objects in the shared memory of the present invention can provide transparent access to the C++ object for all processes accessing the shared memory, wherein the process of accessing the shared memory is in itself The address of the shared memory mapped in the process space can be the same or different; and the biggest feature of the C++ object is that it can include pointer attributes or pointer array attributes, and the pointer or its member pointers point to other C++ objects stored in the shared memory. is recursive until a C++ object that does not include pointer properties or pointer-array properties.

In order to clearly describe the present invention, please refer to FIG. 5 again, which is an application example of the method of the present invention.

The data refresh process updates the database changes to the shared memory according to the needs of the application. This update process will affect the change of the storage structure of the shared memory; the client process (including client processes 1, 2, 3, etc.) through a certain algorithm ( Described algorithm can be half search, bubbling search etc.), finds the object that oneself needs, such as shown in the figure: client process 1 finds class A object 1, client process 2 finds class A object 2, client process 3 finds class A Object 3, etc.; different objects contain different sub-objects, the number can be 0...n, but at different times, the relationship between objects in the shared memory changes, that is, it depends on the database The relationship between the data in . As shown in the figure, at time 1, the sub-objects of class A object 1 include class B object 1, and the sub-objects of class A object 2 include class B object 2 and class B object 3, etc.; As shown by the dotted line), the sub-objects of class A object 1 include class B object 1 and class B object 2, and the sub-objects of class A object 2 include class B object 3 and so on.

Therefore, when the client process accesses the change information in the database, it does not need to directly access the database, and can learn the change information in the database in real time through the change of the association relationship between the object it uses and other objects in the shared memory.

It can be seen from the above steps that the characteristics of this embodiment are: through a data refresh process, the data shared in the database is refreshed into the shared memory according to the needs of the application. When the client process uses the data, it does not need to access the database, but directly accesses the shared memory. You can correctly access the required objects, that is, access the data used; the client process’s access to the shared memory is very fast, and can have a large number of concurrency; in addition, the client process accesses the shared memory. When accessing data, it is like accessing objects created in its own process space, which speeds up the access speed. It can be seen that the solution of the present invention can be applied to real-time, database-like, and object-oriented large-scale C++ applications.

In addition, the present invention also provides a device for storing C++ objects in a shared memory, and the structural diagram of the device is shown in FIG. 6 for details. The device includes: a loading or refreshing unit 11 and a shared memory storage unit 12, wherein the loading or refreshing unit 11 is used to set a section of shared memory for refreshing or for the process of creating a shared memory for the first time, and transfer the shared memory to The address is mapped to a certain virtual address in the process space of the process, the shared memory storage unit 12 is accessed through the virtual address, and the virtual address is stored in the shared memory storage unit 12; the shared memory storage unit 12 , connected to the load or refresh unit 11, for storing C++ objects and/or cascaded C++ objects. The device can increase the object access unit or the object access unit 13 on the above basis, and the object access unit is used to access the C++ object and/or in the shared memory storage unit 12 by overloading the member reference operator of the C++ class Concatenated C++ objects; the object access unit is used to access the C++ objects and/or concatenated C++ objects stored in the shared memory storage unit 12 through one or more index arrays. The index array itself is also a C++ object.

The specific process of each unit in the device is the same as the implementation process of the above method, see the above for details, and will not be repeated here.

The application and implementation of the device of the present invention will be described below with reference to FIG. 7 .

As shown in FIG. 7 , the operating system allocates a shared memory storage area for the process according to the needs of the process, that is, its shared memory storage area. The shared memory storage area is an independent physical storage area provided by the operating system and can be accessed by multiple processes on the host at the same time. The virtual addresses mapped in different processes can be different, which is determined by the operating system. Determined by the characteristics; shared memory loading or refreshing process, the shared memory loading or refreshing process is mainly used to convert the required data into C++ objects (such as C++ object A, C++ object B, C++ object C, and C++ object shown in the figure D) to store in the requested shared memory storage area or to refresh the data in the shared memory storage area; the client process is the process that uses these data, accessing the C++ object in the shared memory is like accessing the C++ object in its own process The objects generated in the space are accessed in the same way, and the most important thing is that such C++ objects can contain pointer or array pointer attributes, and associate access to other C++ objects stored in shared memory through pointer or array pointer attributes. The technical solution of the present invention mainly provides a capability of realizing cross-process interactive access to C++ objects by means of shared memory, which is mainly applied to application systems developed using C++ language.

The above is only a preferred embodiment of the present invention, it should be pointed out that, for those of ordinary skill in the art, without departing from the principle of the present invention, some improvements and modifications can also be made, and these improvements and modifications can also be made. It should be regarded as the protection scope of the present invention.

Claims (10)

1, a kind of method of storing the C++ object in shared drive is characterized in that, comprises step:

A, for the process that refreshes or shared drive is created in application first is provided with one section shared drive, and with the map addresses of this shared drive on certain virtual address of the process space of described process;

B, described process are visited shared drive by virtual address, and described virtual address is stored in this shared drive, and described virtual address is defined as original virtual;

C, with the C++ object storage of C++ object and/or cascade in shared drive.

2, according to the described method of in shared drive, storing the C++ object of claim 1, it is characterized in that described method also comprises: the member referencing operation symbol of client process by heavily loaded C++ class visits the C++ object that is stored in the shared drive and/or the C++ object of cascade.

According to the described method of in shared drive, storing the C++ object of claim 2, it is characterized in that 3, the address of visit C++ object is: pointer value and shared memory-mapped deduct the poor sum of original virtual to the virtual address of visitor place process.

4, according to the described method of in shared drive, storing the C++ object of claim 1, it is characterized in that, among the step B, the described process that virtual address is stored in this shared drive is specially: the virtual address of the visit shared drive that will shine upon stores on certain fixed position in the shared drive.

According to the described method of in shared drive, storing the C++ object of claim 1, it is characterized in that 5, the C++ object with C++ object and/or cascade among the step C is stored in the shared drive by the mode that pointer links to each other respectively.

6, according to claim 5 described in shared drive the method for storage C++ object, it is characterized in that, by the data load or the process that refreshes the C++ object of C++ object and/or cascade is stored in the shared drive by the mode that pointer links to each other respectively.

7, according to claim 1,5 or 6 described methods of in shared drive, storing the C++ object, it is characterized in that, can be continuous or discontinuous between the C++ object of described storage and/or the C++ object of cascade, and the shared space of each object of storage depends on whether this object comprises the number of array pointer attribute and array pointer.

8, a kind of device of storing the C++ object in shared drive is characterized in that, comprising: loading or refresh unit and shared drive storage unit, wherein,

Described loading or refresh unit, be used to and refresh or shared drive is created in application first process is provided with one section shared drive, and with the map addresses of this shared drive on certain virtual address of the process space of described process, visit shared drive by this virtual address, and described virtual address is stored in this shared drive storage unit;

Described shared drive storage unit links to each other with loading or refresh unit, is used to store the C++ object of C++ object and/or cascade.

9, the described according to Claim 8 device of storing the C++ object in shared drive is characterized in that described device also comprises:

The object accesses unit is used for quoting algorithm by heavily loaded C++ member and visits the C++ object of shared drive storage unit and/or the C++ object of cascade.

10, according to Claim 8 or 9 described in shared drive the devices of storage C++ object, it is characterized in that the connected mode of the C++ object of described C++ object and/or cascade is that pointer links to each other.

Images