RU2632416C2 - Method (options) of object transfer from first process to second process, machine-readable media (options) and data processing system - Google Patents

Abstract

FIELD: information technology.

SUBSTANCE: first process has the first memory address space, and the second process has the second memory address space. A copy of the first object is presented to the first adjacent area of the first memory address space and the second copy of the object is introduced into the second adjacent area of the first memory address space. Corresponding stored values are compared in each location of the first and the second copy of the object in the relative locations within the first copy and the second copy of the object. A location indicator is created in the first copy and the second copy of the object where the corresponding values in the appropriate locations do not match. A copy of the object and a location indicator are provided for transmission to the second process, so that the second process can use the location indicator to adjust the locations in the copy of the object for the second memory address space.

EFFECT: increased transmission rate of program objects between the processes.

24 cl, 4 dwg

Description

FIELD OF THE INVENTION

The present solution discloses a method for providing intermediate data generated during the execution of a computer program from the first process to the second.

State of the art

There are many situations where it is desirable to transfer intermediate data encapsulated in a program object from one computer to another. For example, it may be desirable to move data processing from one computer to another in order to distribute the load across a group or cluster of computers. Alternatively, when processing a client request over a network to a server, for example, a database server, it may be necessary to move the program object back to the client in order to enable the client to continue processing the program object.

Software objects may comprise a combination of executable code, as well as data, and thus may process them and / or provide data to another program object for processing. For example, a program object, such as a function or subprocedure, can be instantiated (i.e., an instance of the program object can be created) by the parent object or the main program to implement certain processes for the calling parent object or main program. Object data can include many types, for example: elementary data types, such as integer, real, Boolean, characters; and structural or abstract data types, such as arrays or lists and user-defined data types, each of which includes examples of data or combinations of data types. The program data can be stored directly in the memory area of the program object or indexed with pointers that contain the addresses of other program objects or data. Transferring program objects, including pointers, can be difficult, in particular, when trying to move a program object from a program or process running in one memory address space on a computer to another program or process that potentially uses a different memory address space.

D.M. Dhamdhere cites in his book Operating Systems: A Concept-based Approach, ISBN: 0070611947, 2006, a general approach to memory allocation at the computer operating system (OS) level. There are known solutions for changing the absolute addressing of data to relative addressing in order to avoid problems when transferring data from the first computer (or process) to another computer (or process). However, such solutions may require memory management tools that can analyze the content and associate it with the process. This analysis can be especially burdensome if there is no a priori knowledge about the nature of the processed object.

In US patent US8566536 (October 22, 2013), describes the separation of direct access physical memory between processes. The memory address space is associated with each process by populating the first entry in the high-level virtual address table for each process. Each address space is created and associated with this process, the main core initiates the creation of a main list of entries in the table of high-level virtual addresses of each address space for each process. Thus, the address space of each process is mutually connected with each process by filling in one or more consecutive entries in the table of high-level virtual addresses with the first entry in the table of high-level virtual addresses of other processes. This solution, however, depends on the functionality provided by the processor core.

The objective of this solution is to provide a more easily applicable mechanism for transferring software objects between processes.

SUMMARY OF THE INVENTION

The first object of this solution is a data processing method for transferring an object from a first process to a second process, wherein the first process has a first address space and the second process has a second address space. The method is performed by a processor of a computer device performing the first process, the method comprises providing a first copy of an object to a first adjacent area of a first memory address space; and providing a second copy of the object to a second adjacent area of the first memory address space. For each location of the first and second copies of the object at the respective locations in the first copy of the object and the second copy of the object, the stored corresponding values are compared. A location index is created in the first copy of the object and the second copy of the object, in which the corresponding values at the respective locations did not match. A copy of the object and the location index is provided for transmission to the second process so that the second process can use the location index to adjust the locations in the copy of the object for the second memory address space.

In some embodiments, the method also comprises obtaining a pointer to the specified object for transmission; and also replacing the default memory allocator with a user memory allocator, wherein the user memory allocator is configured to allocate memory in an adjacent memory area. In this case, providing said first copy comprises said object for transmission to said first adjacent memory area allocated by said user memory allocator; and providing said second copy comprises copying said object for transmission to said second adjacent memory area allocated by said user memory allocator. Alternatively, the method also comprises: obtaining a pointer to the specified object for transmission, the specified object occupying the first adjacent memory area allocated by the user memory allocator. In this case, providing said second copy comprises copying said object for transmission to said second adjacent memory area allocated by said user memory allocator.

In some embodiments, providing a copy of said object comprises copying either said first copy of said object or said second copy of said object to a buffer.

In some embodiments, said copied first or second copy of said object is located at a base address in said first memory address space, and said method further comprises extracting said base address from values of said copy of said object to said buffer at each location in said location index.

In some embodiments, the copied first or second copy of the specified object is located at the base address in the specified first memory address space, and the method further comprises extracting the specified base address from the values of the copied first or second copy of the object at each location in the specified location index before copying to the specified buffer .

Some embodiments comprise providing a size of said object with said copy of said object and said location index for transmission to said second process.

Some embodiments are implemented with a serialization function that performs the indicated steps of the method in response to a call to the parent to transmit the specified object.

In some cases, said first process is instantiated on a first computer device, and a second process is instantiated on a second, different computer device.

Alternatively, said first process is instantiated on a first computer device, and a second process is instantiated on a first computer device later. In some embodiments, providing said copy of said object and said location index for transmission comprises storing said copy of said object and said location index in persistent memory. In this case, persistent memory can contain either computer memory or non-volatile memory available to both the first and the second process.

Alternatively, providing said copy of said object and said location index for transmission comprises transmitting said copy of said object and said location index to a computer device over a network line.

In some embodiments, the first process is a C compiled program, and said user memory allocator is configured to implement an overloaded memory allocation function (malloc ()). In other embodiments of the present technology, the first process is a C ++ compiled program, and said user memory allocator is configured to implement the overloaded new () function.

Both said first and second memory address space may be a virtual memory address space.

The second object of this solution is a data processing method for transferring an object from a first process to a second process, the first process having a first address space, and the second process having a second address space. The method is performed by a processor of a computer device performing the second process, the method includes obtaining a copy of the object and a location index in the copy of the object, pointing to a location indicator in the copy of the object. The object is copied to an adjacent area of the second address space of the memory, and the area has a base address. The base address value is added to the object values in the adjacent area of the second memory address space at each location in the location index.

Some embodiments further comprise obtaining a base address for the specified object in the indicated first memory address space and extracting the specified base address from the specified object in the specified first memory address space from the values of the specified object in the specified adjacent region of the specified second memory address space at each location in specified location index.

Some embodiments include obtaining the size of the specified object and allocating an adjacent memory area of at least the specified size in the specified second memory address space.

Some embodiments are implemented with a deserialization function that performs the indicated steps of the method in response to a call to the parent object to obtain the specified object.

Another object is a computer software and hardware product, which includes executable instructions that are stored on a computer-readable medium, and when executed, the computer device is configured to perform the above methods.

An additional object is a data processing system comprising a first computer device connected to a second computer device, each configured to perform the above methods.

BRIEF DESCRIPTION OF THE DRAWINGS

Next will be described various examples of embodiments of the solution with reference to the relevant drawings, where:

in FIG. 1 schematically depicts a system for providing intermediate data created during the implementation of a solution from a first process to a second process, the system being made in accordance with non-limiting embodiments of the present solution;

In FIG. 2 shows a serialization method executable in the system of FIG. one.

In FIG. 3 shows a deserialization method executable in the system of FIG. one.

In FIG. 4 shows an example of serialization and deserialization of objects used in the methods illustrated in FIG. 2 and 3.

DETAILED DESCRIPTION OF THE INVENTION

In FIG. 1 is a diagram of a system 100 including computer devices 20 and 21. It is important to keep in mind that ranking server 100 is only one embodiment of the present solution. Thus, the entire following description is presented only as a description of a representative example. This description is not intended to determine the scope or scope of this decision. Some useful examples of modifications to the system 100 may also be covered by the following description.

The purpose of this is also exclusively to help in understanding, and not to determine the scope and boundaries of this decision. These modifications are not an exhaustive list, and it will be understood by those skilled in the art that other modifications are possible. In addition, this should not be interpreted so that where it has not yet been done, i.e. where examples of modifications have not been set forth, no modifications are possible, and / or that which is described is the only embodiment of this element. As will be clear to a person skilled in the art, this is most likely not the case. In addition, it should be borne in mind that the system 100 is, in some specific manifestations, a fairly simple embodiment, and in such a case is presented here in order to facilitate understanding. As will be clear to a person skilled in the art, many embodiments of the present solution will have much greater complexity. In a first embodiment of the present solution, the computer device 20 is operatively connected to a data storage device 30 that stores program code 10. The data storage device 30 may be a memory device such as a hard disk drive integrated in the computer device 20, or the data storage device 30 may be connected with a computer device 20 over a network (not shown) or through any suitable wired or wireless connection. In the context of the present description, unless specifically indicated otherwise, “computer device” means a hardware device capable of working with software suitable for solving the corresponding problem. Thus, some examples of electronic devices (among other things) include universal personal computers (desktop computers, laptops, netbooks, etc.), mobile computer devices, smartphones, tablets, and network equipment such as routers, switches, and gateways . It should be borne in mind that a device behaving like a computer device in the present context can behave like a server in relation to other electronic devices. The use of the expression “computer device” does not exclude the possibility of using multiple electronic devices to receive / send, execute or initiate the execution of any task or request, or the consequences of any task or request, or the steps of any of the above methods.

The instance 101 of the program 10 is loaded into the address space of the memory 16 of the computer device 20. The memory 16 may comprise a virtual memory system with physical memory separate from the address space, but for the sake of simplicity, the memory is shown in FIG. 1 as a simple block 16.

The program instance 101 is specifically made, in turn, for instantiating a number of program objects from 121 to 123. As described above, program objects may contain examples of functions created during the execution of program instance 101 or simple or structured data objects, some of which may contain pointer values that point to other functions or data. Software objects are usually arranged in a hierarchical order, with the parent objects invoking the instantiation of one or more child objects. In FIG. 1 shows only two levels of child objects, with objects from 121 to 123 being instantiated by instance 101 of the program and shown as having one or more instantiated child objects. Thus, the program object 121 has the instantiated object 1211, and the program object 122 has the instantiated objects 1221 ... 1222, and the program object 123 has the instantiated object 1231. However, it will be clear that even in a medium-complexity program, the hierarchy of objects can contain many levels of objects.

For the parent object of program 10, such as the main program or program object, it may be desirable to transfer the child object with the data at an intermediate stage of processing to another instance of the program, where further processing of the object or processing by the object can be performed. To this end, embodiments of the present solution describe a serialization function and a corresponding deserialization function.

The serialization function allows the parent object (and the main program 10 or subsidiaries or children of lower levels in the first instance 101 of the program) to indicate their child object, which must be passed to the serialization function, and the serialization function then writes information about the object to buffer 60, which can then either be stored in read-only memory, such as a data storage device 30, or transmitted over a network connection 40 for later use by another instance 102 of Ranma. The instruction provided to the serialization function may include the calling parent object, passing the object for further transmission, or directly, i.e. passing the entire object, either by reference, i.e. using a pointer to an object. Another instance of the program may be a second instance 102 of the program 10 running on another computer device 21; the instance may be a later instance of the program 10 running on the same computer device 20, some time after the first instance 101 of the program has finished processing; or the second instance may be an instance of another program other than program 10. FIG. 1, another instance of a program 102 is shown for simplicity as a separate program running on a second computer device 21 connected to a first computer device 20.

The deserialization function enables the parent object, in this example, the object 120 in the second instance of the program 102 to indicate a serialized set of values in the buffer 60, either retrieved from the storage device 30, or received through the network connection 40, and to obtain an instance of the program object from these values In particular, it has the meaning of pointers that are correctly associated with the address space in the memory 17 in which the second instance of the program 102 is instantiated. In any case, the serialized information retrieved by the deserialization function is described as being obtained from buffer 60 - this does not imply that the information was stored in an energy-resistant memory such as data storage device 30, the buffer might as well contain an intermediate receiving buffer in the network receiving side of the computer device 21.

In FIG. 2 illustrates steps involving serializing objects in accordance with embodiments of the present technology.

In a first step 200 carried out by the parent, an object is prepared to be serialized. This includes said program code (machine-readable code) in the program instance 101, which processes the data to the state required before it is sent to another program for further processing. So, for example, when the instance 101 of the program is a database program, this preparation may contain the answer of the parent object (which with high probability can turn out to be the child of other objects) to the request from the client program, the implementation of the SQL query (Structured Query Language - structured language queries) in the database and then creating an object related to the database, including the results of the request, in order to transfer the object related to the database back to the requesting client. In other examples, the parent may need to pass an object containing a combination of program code and data to another instance of the program for further processing.

The next step 202 can be carried out either by the parent object, or within the framework of the requested instance of the serialization function, which should serialize the program object and which was passed either to the program object (directly) or to a pointer to the program object (by reference), which should be serialized. At this point, enough memory from memory 16 is allocated to provide the required task with the serialization function. As will be described, instances of the serialization function need to create either one or two copies of the object for serialization, and thus, sufficient available memory is needed for this process.

As will be understood, a program object can be stored either in dynamic memory (heap) or in the software stack (stack). Dynamic memory is a memory area of a computer whose distribution is not automatically controlled by the operating system that stores the program. This free space is usually larger than the stack. To allocate the memory of variables in dynamic memory in a C program, the built-in C memory allocation functions malloc () or calloc () are used. In C ++, the new () and delete () functions are equivalent; in other languages, similar functions are used.

For variables allocated in dynamic memory, you can use the C free () function or the C ++ delete () function to redistribute this memory if this memory is no longer necessary. Failure to do this leads to loss of access to memory (during program execution), when dynamic memory is still allocated and inaccessible to other processes.

Due to the many possible distributions and redistributions of dynamic memory during program execution in virtual memory systems, dynamic memory variables can be stored in non-contiguous areas of virtual memory as well as physical memory.

Thus, unless the call to the parent object has provided otherwise, the serialization function cannot conclude that the program object that it transmitted (either directly or by reference) was stored in an adjacent memory area.

In embodiments of the present solution, if it has not been implemented by the calling program or parent, the serialization function ensures that copies of the program object to be serialized are stored in an adjacent memory area. At 204, this includes replacing the default global memory allocator with a custom memory allocator. A user memory allocator provides distribution of copies of an object for serialization in respective adjacent memory areas that was allocated to the function in step 202.

For programs written in C or C ++, control over the allocation of program dynamic memory can be achieved by overloading the malloc (), calloc (), and new () functions in such a way that as new variables are declared and allocated during program execution , they are written to adjacent memory areas instead of being allocated to non-adjacent memory locations - virtual or physical. Equivalent procedures can be applied to programs written in other languages; or other procedures may be applied to achieve the same results in accordance with the program operating system environment.

If the serialization function needed to move the default memory allocator, then at steps 206 and 208, the serialization function creates two copies of the object for serialization in the memory space allocated at step 202.

In the memory allocator, the distribution of objects in adjacent memory areas is used by default in the instance 101 of the program, then a copy of the object is transferred to the serialization function (either directly or by reference), it can be used as the first copy, and so only one object needs to be copied to the serialization function times to provide two copies of the object, each of which is stored in the corresponding adjacent memory area, for analysis.

In any case, after steps 206 and 208, two copies of the original object occupy the corresponding adjacent memory areas that are available for serialization.

Since any form of an object can be passed to the serialization function, the serialization function does not make any conclusions about the nature of the object or its structure. The serialization function will only know the size of the object and that the object will contain a combination of pointers and data.

Two copies of the object have the same size and data. The same in the context of the same amount of memory and that the information in them is the same. However, the values of the pointers will differ, because they point to different data instances at the corresponding memory locations for the first and second copies of the object. At step 210, the serialization function compares two copies of the object, address by address, and creates a list of differences between two copies of the object stored in the corresponding adjacent memory areas. This is achieved in a simple way - by setting the pointer to the base address of the first copy of the object and the base address of the second copy of the object and comparing the values stored at each address before moving each pointer one by one to the following addresses for comparison and repeating this procedure for each address throughout the entire volume of the object . Any equivalent procedure may also be used.

In each case, when there is a difference between the contents of the addresses in the first copy of the object and the corresponding address in the second copy of the object, the scope of the differences will be the same and will relate to the difference between the base addresses of the first copy of the object and the base address of the second copy of the object.

In FIG. 4, after step 208 in FIG. 2, the first instance of the object, copy 1 of this size is stored in an adjacent memory area, starting from the base address (1). The second instance, copy 2, of the same size, is stored in an adjacent memory area, starting at base address (2). For simplicity, FIG. 4 shows a single address in each instance of an object containing a pointer, the pointer pointing to a piece of data located in a specific place in the memory space occupied by the instance of the object. In copy 1, the pointer value located at the address base address (1) plus the pointer offset (PtrOffset) contains the base address (1) plus the data offset (DataOffset), and in copy 2 the pointer value located at the address base address (2) plus the offset The pointer (PtrOffset) contains the base address (2) plus the data offset (DataOffset). Thus, the difference in value for each instance of the pointer in the object for serialization will be the base address (2) minus the base address (1).

Thus, in step 210, the serialization function identifies each location of the PtrOffset pointer in the copy of the object, as well as the address of the base address plus DataOffset stored in the location of the pointer.

At step 212, a copy of the object and the information created at step 210 are written to the buffer and either stored in the buffer 60 or transferred to another processing device 21 via a network connection 40. Either the first copy (copy 1) or the second copy (copy 2) can be used as sources to provide a copy of the object to the buffer.

One way of encoding the information in step 212 comprises moving values to locations identified as containing pointers with relative addresses, and then simply storing the offset list, PtrOffset, for each location of the pointer in a copy of the object to be transmitted. Thus, in the example of FIG. 4, where copy 1 is used as the source, the base address value (1) plus the DataOffset first stored in the specified pointer location will be replaced by the adjusted relative value of the DataOffset pointer in buffer 60, and the PtrOffset address will be stored as an entry in the list (or array) of PtrIndex , which is written to buffer 60 along with the adjusted copy of the object, including the relative address of the pointer at each location of the pointer. Finally, an object size indicator is also written to buffer 60.

It will be obvious that the adjustment of pointer addresses can either be done on the original copy of the object before it is written to the buffer; or adjustment can be made on the corresponding values already in the buffer.

In the first case, copy 2 can be used as a source, since this copy can be removed from memory as soon as serialization is completed, which allows copy 1 to remain available for use in instance 101 of the program. Saving or not saving copy 1 with instance 101 of the program depends on whether the object will subsequently be used by instance 101 of the program. For example, it may be desirable to provide both instances 101 and 102 of the program with parallel processing of the transferred program object, in which case the original object must be stored, and thus its pointer location value should not be adjusted.

Now, FIG. 3 and a deserialization function that makes it possible to read a serialized memory object. As already described, deserialization can occur on another computer device 21 to which a serialized copy of the object is sent, or it can be the same computer device 20 with the same memory device or with a different memory device.

The deserialization function is called by the parent object, for example, object 120, which needs to continue processing the serialized object. The calling parent does not have to be the same as the parent that originally serialized the object in buffer 60, and also, as described above, the program instance 102 does not have to be the same instance as the program instance 101.

The deserialization function may be transferred either to a copy of the buffer in which the serialized object was recorded, or to a reference to the location of the buffer in step 300. As shown in FIG. 4, buffer 60 will contain a copy of the object where the pointers were replaced with the corresponding addresses; index of the pointer (offset in the copy of the object); PtrIndex, and, in this example, an indication of the size of the object. Knowing the size of the object in the buffer 60 enables the deserialization function to determine the boundary 62 between the object information stored in the buffer 60 and the PtrIndex information stored in the buffer 60.

At step 302, the deserialization function allocates enough memory to create an object from the buffer information using the size information obtained from the buffer 60. In the example of FIG. 4, the selected area begins behind the base address (3).

At step 304, the deserialization function then creates the object by copying information about the object in the buffer to the memory area allocated for the object at step 302.

At step 306, the PtrIndex information stored in the buffer 60 after the boundary 62 enables the deserialization function to determine the location of each pointer address in the allocated memory area and add the base address (3) to the corresponding pointer value stored at this address to convert the relative value of the pointer to the absolute value of the pointer, correctly indicating the correct data address in the memory area 17.

At step 308, the deserialization function may return the deserialized object of the calling function, which then continues processing using the object. Another simple example with an explanation: let the first copy of the object occupy an adjacent memory area, and the values at each memory location for the object are as follows: First = 4178 [3] 2654 [5] 78.

The values shown in parentheses indicate the addresses of the pointers, although the serialization function cannot distinguish these values from the data values stored at other addresses for the object in memory. However, in this example, when a second copy of an object is copied to an adjacent piece of memory, the values of each location in memory may look like this:

Second = 4178 [4] 2654 [6] 78.

Particular attention is drawn to the fact that the allocation of the value of pointers changed during the transition from one copy of the object to the next, as well as the fact that the difference between the values is constant.

The serialization function sequentially compares two copies of an object to find addresses representing differences in value originating from the copy.

As can be seen, starting from the index [0], such differences arise in the locations [4] and [9] highlighted above. These offsets are stored, and information at these locations is adjusted.

Let the base address of the first copy of the object be 2. In this case, this value is extracted from the values at locations [4] and [9] in the first copy to create relative addresses at these locations. The values written to buffer 60 for this object will therefore be:

Buffer = 4178 [1] 2654 [3] 78, [4], [9], 12.

In this case, brackets and punctuation are also provided for clarity - there is no need for such delimitations in buffer 60.

The last buffer entry indicates that the object information occupies the first 12 locations in memory in the buffer. The values following the object information and the previous size information indicate that the values in the index [4] and [9] need to be adjusted for the memory space 17 of the receiver process.

It will be understood that 12 addresses of object information, 2 indexes and size information can be written to buffer 60 in any suitable order, which allows the receiving side to determine the size of the program object that has been serialized and the locations in the program object that need to be adjusted for space 17 memory of the receiver process.

Continuing this example, if the base address for the object in the memory space 17 of the destination process was, for example, 5, this value should be added to the locations [4] and [9] to create a deserialized object in memory as follows:

Soru: 4178 [6] 2654 [8] 78

This deserialized object can be passed back to any calling parent 120 for processing in the usual manner, including, for example, reserializing the object for further processing by another computer device.

Obviously, many alternative solutions are possible.

For example, pointer values in a serialized copy of an object in buffer 60 need not be adjusted before passing the object. In this case, the base address of the original copy of the object in memory 16 can be written to buffer 60. Then, the initial value of the pointer, the initial base address from the buffer and the base address, for example, the base address (3) for the deserialized version of the object in the memory 17 of the computer device 21 can be used when deserializing the object to adjust for the memory space 17 of the process-receiver. Thus, regardless of whether the object has been adjusted before being transferred to the receiving process, as described in relation to FIG. 2-4; or the base address of the source object is transmitted with the serialized object in such a way that it can be adjusted by the receiving side, the object is transmitted with sufficient information to make it independent of the base address for the source object and thus allow the receiving side to make adjustments for the process memory space 17 -receiver.

And also because PtrIndex will differ in length according to the number of pointers in the object, the size indicator of the object is written to the buffer to enable the deserialization function to distinguish between the object and PtrIndex data. However, if a specific area, such as the size of an object, was allocated to PtrIndex, then, although this would be less efficient, it would not be strictly necessary to write the size of the object to buffer 60.

Similarly, in the examples provided, PtrIndex unconditionally identifies the locations in the copy of the object corresponding to the pointers in the object. In this case, also, although it is more likely to be less efficient due to the fact that fewer pointers will be expected than other values in the object, this information can also be transmitted negatively, with PtrIndex (or equivalent) including directions to locations in an object that are not pointers. This will indicate to the deserialization function which addresses should not be adjusted for the memory space 17 of the destination process, leaving other addresses, such as pointer addresses, to be adjusted.

In the context of the present description, unless specifically indicated otherwise, the term "data" includes any information that may be stored, for example, in a database, or may be transmitted in electronic form, for example, by stream. Thus, data includes, but is not limited to, audiovisual works (images, videos, sound recordings, presentations, etc.), location data, digital data, etc., text (opinions, comments, questions, messages and etc.), documents, tables, etc.

In the context of the present description, unless specifically indicated otherwise, the term "database" means any structured data set that is independent of the specific structure, database management software, hardware of the computer on which data is stored, used, or otherwise are available for use. The database may reside on the same hardware that runs the process that stores or uses the information stored in the database, or it may reside on separate hardware, such as a dedicated server or multiple servers.

It will be understood that although the above method has been described for the purpose of an example with a specific sequence of steps, the various steps may be arranged in a different order, where possible, to achieve the same result.

Embodiments of the present solution find particular application, for example, in the distribution of software objects between devices; providing processing on virtual machines, where, for example, processing and / or decision making can be moved between the remote server and local processors; backup / virtualization systems; and in compilers and code execution applications.

In the context of the present description, unless specifically indicated otherwise, “server” means a computer program running on appropriate equipment that is able to receive requests (for example, from computer devices) over the network and to fulfill these requests or initiate the execution of these requests. The equipment may be a single physical computer or a single physical computer system, but neither is required. In the context of the present description, the use of the expression “server” does not mean that every task (for example, received commands or requests) or any specific task will be received, executed or initiated to be executed by the same server (that is, by the same software software and / or hardware); this means that any number of software elements or hardware devices can be involved in receiving / transmitting, executing or initiating the execution of any request or the consequences of any request associated with the client device, and all this software and hardware can be one server or several servers , both options are included in the expression “at least one server”.

In the context of the present description, unless specifically indicated otherwise, the term “computer-supported computer information medium” means a medium of absolutely any type and nature, including RAM, ROM, disks (CDs, DVDs, diskettes, hard drives, etc.). e.), USB flash drives, solid state drives, tape drives, etc.

In the context of the present description, unless specifically indicated otherwise, the words "first", "second", "third", etc. used in the form of adjectives solely to distinguish the nouns to which they relate from each other, and not for the purpose of describing any specific relationship between these nouns. So, for example, it should be borne in mind that the use of the terms “first device” and “third device” does not imply any ordering, chronology, hierarchy or ranking (for example) of devices / between devices, as well as their use (in itself) does not imply that a certain “second device” must exist in a given situation. Hereinafter, as indicated here in other contexts, reference to the “first” element and the “second” element does not exclude the possibility that it is one and the same actual real element. So, for example, in some cases, the “first” device and the “second” device can be the same software and / or hardware, and in other cases they can be different software and / or hardware.

Each embodiment pursues at least one of the aforementioned objectives and / or objects. It should be borne in mind that some of the objects of this decision, obtained as a result of attempts to achieve the aforementioned goal, may satisfy other goals not specifically indicated here.

Thus, embodiments of the present solution can be summarized as follows, in a structured, numbered paragraphs.

1. ^* A method for transferring an object (12) from the first process (10 ') to the second process (10''), the first process having a first memory address space (16), and the second process having a second memory address space (16'); the method is performed by a processor of a computer device (20), performing said first process; the method contains:

providing (206) a first copy of the specified object in the first adjacent area of the specified first memory address space;

providing (208) a second copy of said object in a second adjacent area of said first memory address space;

for each location of the specified first and second copies of the specified object, a comparison (210) of the corresponding values stored in the respective locations within the specified first copy of the specified object and the specified second copy of the specified object;

creating a location index in the specified first and second copies of the specified object, in which the indicated corresponding values in the respective locations did not match;

providing (212) a copy of said object and said location index for transmission to said second process so that said second process can use said location index to adjust said locations in said copy of said object for said second memory address space.

CLAUSE 1. The method according to claim 1, wherein said method further comprises:

receiving (200) a pointer to the specified object for transmission;

replacing (204) the default memory allocator with a user memory allocator, wherein the user memory allocator is configured to allocate memory in an adjacent memory area;

where the provision of the specified first copy contains a copy (206) of the specified object for transmission to the specified first adjacent memory area allocated by the specified user memory allocator; and

providing said second copy (208) comprises copying said object for transmission to said second adjacent memory area allocated by said user memory allocator; and

CLAUSE 2. The method according to claim 1, wherein said method further comprises:

obtaining a pointer to the specified object for transmission, and the specified object occupies the first adjacent area of memory allocated by the user memory allocator; and

providing said second copy comprises copying said object for transmission to said second adjacent memory area allocated by said user memory allocator.

CLAUSE 3. The method according to claim 1, wherein providing a copy of the specified object comprises copying either the specified first copy of the specified object or the specified second copy of the specified object to the buffer (60).

CLAUSE 4. The method of claim 1, wherein said copied first or second copy of said object is located at a base address in said first memory address space and wherein said method further comprises extracting said base address from values of said copy of said object into said buffer in each location in the specified location index.

CLAUSE 5. The method of claim 1, wherein said copied first or second copy of said object is located at a base address in said first memory address space, and wherein said method further comprises extracting said base address from values of the copied first or second copy of the object in each location in the specified location index before copying to the specified buffer.

CLAUSE 6. The method according to claim 1, wherein the method further comprises providing the size of the specified object with the specified copy of the specified object and the specified location index for transmission to the specified second process.

CLAUSE 7. The method of claim 1, wherein the method includes a serialization function that performs the steps in response to a call to the parent to transmit the specified object.

CLAUSE 8. The method according to claim 1, wherein said first process is instantiated on a first computer device (20) and a second process is instantiated on a second, different computer device (20 ').

CLAUSE 9. A method of transferring an object from a first process to a second process, the first process having a first memory address space, and the second process having a second memory address space; the method is performed by a processor of a computer device by performing said second process; the method contains:

obtaining (300) a copy of the specified object and the location index in the specified copy of the object, indicating location pointers in the specified copy of the specified object;

copying (304) the specified object into the adjacent area of the specified second address space of memory, and the specified area has a base address; and adding (306) the specified base address value to the values of the specified object in the specified adjacent area of the specified second memory address space at each location in the specified location index.

CLAUSE 10. The method of claim 10, the method further comprises obtaining a base address for the specified object in the specified first memory address space and extracting the specified base address from the specified object in the specified first memory address space from the values of the specified object in the specified adjacent area of the specified second memory address space at each location in the specified location index.

CLAUSE 11. The method of claim 10, the method further comprises obtaining a size of said object and allocating (302) an adjacent memory region of at least said size in said second memory address space.

CLAUSE 12. The method of claim 10, wherein the method includes a deserialization function that performs the steps in response to a call to the parent to obtain the specified object.

CLAUSE 13. A computer software product that includes executable instructions that are stored on a computer-readable medium, and during which the computer device is configured to perform the method according to any one of paragraphs. 1-13.

CLAUSE 14. A data processing system comprising a first computer device connected to a second computer device, said first computer device being configured to perform steps 1, and a second computer device configured to perform steps 10.

Additional and / or alternative characteristics, aspects and advantages of embodiments of the present technology will become apparent from the following description, the attached drawings and the attached claims.

Those skilled in the art will understand that in the present description, the expression “receiving data” from a user means receiving by the computer device data from the user in the form of an electronic (or other) signal. In addition, those skilled in the art will understand that displaying data to a user through a graphical user interface (for example, a screen of a computer device and the like) may include transmitting a signal to the graphical user interface, this signal contains data that can be processed, and at least a portion of this data may be displayed to the user via a graphical user interface.

Some of these steps, as well as signal transmission-reception, are well known in the art and, therefore, have been omitted in specific parts of this description for simplicity. Signals can be transmitted — received using optical means (for example, optical connection), electronic means (for example, wired or wireless connection) and mechanical means (for example, based on pressure, temperature or another suitable parameter). Modifications and improvements to the above-described embodiments of the present technology will be apparent to those skilled in the art. The preceding description is provided as an example only and is not subject to any restrictions. Thus, the scope of the present technology is limited only by the scope of the attached claims.

Claims (38)

1. A method of transferring an object from a first process to a second process, the first process having a first memory address space, and the second process having a second memory address space; performed by a processor of a computer device executing said first process; and including: providing a first copy of said object in a first adjacent area of said first memory address space; providing a second copy of the specified object in the second adjacent area of the specified first address memory space; comparing for each location of the indicated first and second copies of the specified object the corresponding values stored in the respective locations within the specified first copy of the specified object and the specified second copy of the specified object; the formation of a location index in the specified first and second copies of the specified object, in which the indicated corresponding values at the respective locations differ; providing a copy of the specified object and the specified location index for transmission to the specified second process for use in adjusting the specified locations in the specified copy of the specified object for the specified second memory address space. 2. The method according to p. 1, in which receive a pointer to the specified object for transmission; replacing the default memory allocator with a user-defined memory allocator configured to allocate memory in an adjacent memory region; wherein the provision of said first copy comprises copying said object for transmission to said first adjacent memory region allocated by said memory allocator specified by a user; and providing said second copy comprises copying said object for transmission to said second adjacent memory area allocated by said user-specified memory allocator. 3. The method according to p. 1, in which get a pointer to the specified object for transmission, and the specified object occupies the first adjacent memory area allocated by a user-specified memory allocator; and providing said second copy comprises copying said object for transmission to said second adjacent memory area allocated by said user-specified memory allocator. 4. The method of claim 1, wherein providing a copy of said object comprises copying said first copy of said object or said second copy of said object to a buffer. 5. The method according to claim 1, in which the specified copied first or second copy of the specified object is located in the base address in the specified first memory address space and the specified base address is extracted from the values of the specified copy of the specified object to the specified buffer at each location in the specified location index. 6. The method according to claim 1, in which the specified copied first or second copy of the specified object is located in the base address in the specified first memory address space and the specified base address is extracted from the values of the copied first or second copy of the object at each location in the specified location index before copying to the specified buffer. 7. The method according to claim 1, in which they report the size of the specified object with the specified copy of the specified object and the specified location index for transmission to the specified second process. 8. The method according to p. 1, in which use the serialization function that performs these steps when calling the parent object to transfer the specified object. 9. The method of claim 1, wherein said first process is instantiated on a first computer device, and a second process is instantiated on a second excellent computer device. 10. The method according to claim 1, wherein said first process is instantiated on a first computer device, and then a second process is instantiated on a first computer device. 11. The method according to claim 1, wherein said providing a specified copy of the specified object and the specified location index for transmission comprises recording a specified copy of the specified object and the specified location index in persistent memory. 12. The method of claim 11, wherein the persistent memory comprises computer memory or non-volatile memory available to said first and said second process. 13. The method according to claim 1, wherein said providing a specified copy of the specified object and the specified location index for transmission includes transmitting the specified copy of the specified object and the specified location index to the computer device via a network line. 14. The method of claim 2, wherein said first process is executed as a compiled C program, and said user-specified memory allocator is configured to perform an overloaded memory allocation function. 15. The method of claim 2, wherein said first process is executed as a compiled C ++ program, and said user-specified memory allocator is configured to perform an overloaded function. 16. The method of claim 1, wherein said first and said second address memory space is implemented as a virtual address memory space. 17. Machine-readable medium, including executable computer-readable codes, the execution of which the computer device implements the method according to claim 1. 18. A method of transferring an object from a first process to a second process, the first process having a first memory address space, and the second process having a second memory address space; performed by the processor of the computer device that performs the specified second process, and including: obtaining a copy of the specified object and the location index in the specified copy of the object, indicating location pointers in the specified copy of the specified object; copying said object to an adjacent region of said second address memory space, said region having a base address; and adding the specified base address value to the values of the specified object in the specified adjacent area of the specified second memory address space at each location in the specified location index. 19. The method according to p. 18, which obtains the base address for the specified object in the specified first memory address space and extracts the specified base address from the specified object in the specified first memory address space from the values of the specified object in the specified adjacent area of the specified second memory address space in each location in the specified location index. 20. The method according to p. 18, in which data is obtained on the size of the specified object and allocate an adjacent memory region of at least the specified size in the specified second memory address space. 21. The method according to p. 18, in which use the function of deserialization that performs these steps when calling the parent object to obtain the specified object. 22. Machine-readable medium, including computer-readable codes, the execution of which the computer device implements the method according to p. 18. 23. A data processing system including a first computer device associated with a second computer device, wherein said first computer device is configured to implement the method of claim 1, and the second computer device is configured to implement the method of claim 18. 24. The system of claim 23, wherein said first and second computer devices are various devices.

Images