<h2 id="d47e684b-a85f-49d8-befd-857d58b77242" data-toc-id="d47e684b-a85f-49d8-befd-857d58b77242">There are use cases when we need to replicate the data from one machine (origin) to a couple of other remote machines over the network. </h2>The most common use case is High availability and fault tolerance. In this article, we will be going to discuss how a machine can replicate the in-memory data structures ( Data structures kept in RAM ) to a remote machine AS IT IS. By AS IT IS I mean, copy-pasting the snapshot of the data structures kept in memory ( the data, and the pointer linkages between them ) into the RAM of the remote machine.<img src="https://letcheck.b-cdn.net/2587/clti8di6a0547nm9na6eo7oxz.webp">The diagram above shows process p1 on machine 1 has, linked list, representing the application heap state. The process p1 replicates the clone of its Virtual memory pages comprising the heap state to remote process p2.The programmer doesn't have to worry about the data structures' internals or pointer linkages between them. The technique is generic and is Data structure agnostic (hence, the word Transparent in the title). This is one of the biggest advantages of copying data from one machine to another over the serialization technique. However, this technique is highly machine-dependent. The Origin and Recipient machine needs to have the same similar arch for this technique to work. For example, this method of cloning the data structures is not feasible between little and big endian machines.To begin with, the process of cloning or snapshot-ing the in-memory state of process p1 to RAM of process p2 on remote machine involves 8 steps :<ol><li style="color: rgb(36, 36, 36)">P1 : Request VM pages from kernel using mmap( ) sys call.</li><li style="color: rgb(36, 36, 36)">P1 : Use the requested VM pages as memory pool for (de)allocation of memory chunks as requested by application. For this you need to write custom malloc/free calls (allocator_alloc_mem/ allocator_afree_mem) which operate on requested VM pages to service application memory requests. Let the application p1 create some linkedlist for demonstration purposes using custom malloc. I show it through code snippets shortly.</li><li style="color: rgb(36, 36, 36)">Socket on P1 : P1 sends the VM page memory over Network socket along with meta data information viz : base address of the VM page, the address of the root objects contained in VM page ( for example, in this scenario the root object is the head of the linked list ), and size of VM page. So basically the data sent over the network would look like this:</li></ol>[base address of VM page][address of root object][VM page size][VM page memory]4. Socket on P2 : P2 recvs the data sent over wire and stores it in buffer5. P2 : Using mmap System Call, P2 reserves a virtual memory page in the Virtual address space exactly at the address base address of VM page. Check the first argument of mmap( ) which helps in accomplishing this task.6. P2 : Blindly memcpy the VM page content from buffer ( used in step 4 ) in VM page created in step 5.7. P2 : Now, using the root address, p2 can access the entire linked list.8. P2 : P2 when done, munmap the VM page(s) created in step 5Let me elaborate the above steps through Code Snippets.<pre><code class="language-c">Step 1 :// Get System Page size using getpagesize() API defined in unistd.h
const uint32_t page_size = getpagesize();// allocate VM page to process using mmap() call
void *vm_page_memory = mmap(NULL, page_size,
 PROT_READ|PROT_WRITE|PROT_EXEC,
 MAP_ANON|MAP_PRIVATE,0,0);if (vm_page_memory == MAP_FAILED) { printf("Error : VM Page allocation Failed\n");
 return -1;
}</code></pre>In Order to perform step 2, let me have an APIs which are equivalent to malloc/free and perform memory allocation/deallocation to the application using VM page as a memory pool. I have skipped the internal implementation of these APIs to keep the Article short and simple. Implementation of these APIs could be found in mem_allocator.h/.c files <a target="_blank" rel="noopener noreferrer nofollow" class="af jq" href="https://github.com/sachinites/IPC/tree/master/IPC/HeapClone">here.</a> APIs prototypes are below :<pre><code class="language-c">Step 2 :// Initialize the VM page obtained in step 1 for memory allocation. base address is the address returned by mmap() in step 1
void allocator_init (void *base_address, uint32_t size);
// API equivalent to malloc
void *allocator_alloc_mem (void *base_address, uint32_t req_size);
// API equivalent to free
void allocator_free_mem (void *addr);</code></pre>Now, we are in a position to perform step 2. Let application P1 create a 3-node linked list using the above memory allocator APIs.<pre><code class="language-c">Step 2 :student_t *stud1 = 
(student_t *)allocator_alloc_mem(vm_page_memory, sizeof(student_t));strcpy((char *)stud1-&gt;name, "Abhishek");
stud1-&gt;roll_no = 1;
stud1-&gt;next = NULL;student_t *stud2 =
(student_t *)allocator_alloc_mem(vm_page_memory, sizeof(student_t));strcpy((char *)stud2-&gt;name, "Shivani");
stud2-&gt;roll_no = 2;
stud2-&gt;next = NULL;
stud1-&gt;next = stud2;student_t *stud3 = 
(student_t *)allocator_alloc_mem(vm_page_memory, sizeof(student_t));strcpy((char *)stud3-&gt;name, "Twisha");
stud3-&gt;roll_no = 3;
stud3-&gt;next = NULL;stud2-&gt;next = stud3;</code></pre>Voila ! This completes step 2. Now Process P1 has in-memory liunkedlist. In Step 3, P1 sends the VM page to process P2 over network with meta information attached. The information is sent as per the below structure format :<pre><code class="language-c">Step 3 :typedef struct vm_page_xmit_ { void *page_base_address; // base address of the VM page 
 uint64_t page_size; // page size
 void *root_address; // address of the first node of 
 // Linked list
 unsigned char page_memory[0]; // entire VM page memory
} vm_page_xmit_data_t;
vm_page_xmit_data_t *vm_page_xmit_data = (vm_page_xmit_data_t *)
 calloc(1, sizeof(vm_page_xmit_data_t) + getpagesize());vm_page_xmit_data-&gt;page_base_address = vm_page_memory;
vm_page_xmit_data-&gt;page_size = page_size;
vm_page_xmit_data-&gt;root_address = (void *)stud1;
memcpy (vm_page_xmit_data-&gt;page_memory, vm_page_memory, page_size);</code></pre>And then using Sockets, you can send vm_page_xmit_data to remote process p2.<pre><code class="language-c">Step 3 :int sent_bytes = sendto(sockfd,
 vm_page_xmit_data,
 sizeof(vm_page_xmit_data_t) + page_size,
 0,
 (struct sockaddr *)&amp;dest,
 sizeof(struct sockaddr));</code></pre>You are recommended to use TCP sockets to guranatee in order and lossless delivery of bytes to remote process p2. We complete Step 3 here. Job of process P1 is over here.Step 4 simply required Process P2 to receive data over socket and store it in its buffer memory.<pre><code class="language-c">Step 4 :unsigned char *buffer =
(unsigned char *)calloc (1, sizeof(vm_page_xmit_data_t)+ page_size);int recv_bytes = recvfrom(sockfd,
 (char *)buffer, buffer_size, 0,
 (struct sockaddr *)&amp;server, &amp;addr_len);</code></pre>In Step 5, P2, Using mmap System Call, P2 reserves a virtual memory page in the Virtual address space exactly at the address base address of VM page. Check the first argument of mmap( ) which helps in accomplishing this task.<pre><code class="language-c">Step 5 :vm_page_xmit_data_t *vm_page_xmit_data = (vm_page_xmit_data_t *)buffer;void *vm_page_memory = mmap(
 vm_page_xmit_data-&gt;page_base_address,
 vm_page_xmit_data-&gt;page_size,
 PROT_READ|PROT_WRITE|PROT_EXEC,
 MAP_ANON|MAP_PRIVATE,
 0, 0);if (vm_page_memory == MAP_FAILED) {
 printf("Error : VM Page allocation Failed, errorno = %d\n", errno);
 return -1;
}</code></pre>In Step 6 , P2 blindly memcpy the VM page content from buffer ( used in step 4 ) in VM page created in step 5.<pre><code class="language-c">Step 6 :memcpy (vm_page_memory, vm_page_xmit_data-&gt;page_memory, page_size);</code></pre>P2 can now access any data structure stored in VM page by process P1 using root address, in this case, a simple linked list. Root address is any address which provide access to the entire data struture. It could be head of linked list, root of the tree etc.<pre><code class="language-c">Step 7 :student_t *stud1 = (student_t *)vm_page_xmit_data-&gt;root_address;
student_t *stud = stud1;while (stud) {
 printf ("Name = %s , Roll No = %u\n", stud-&gt;name, stud-&gt;roll_no);
 stud = stud-&gt;next;
}/* Continue to use the student linked list *//* no need to invoke allocator_init() because the above memcpy do it */stud = (student_t *)allocator_alloc_mem(
 vm_page_memory, sizeof(student_t));
strcpy((char *)stud-&gt;name, "Mayank");
stud-&gt;roll_no = 4;
stud-&gt;next = NULL;
stud-&gt;next = stud1;</code></pre>Congratulations. You are able to clone the snapshot of the virtual memory page from process P1 to P2. Note that, it is mandatory that process create VM page exactly at same base address as of process P1. Thats the reason, Ist argument to mmap( ) in step 5 is crucial.P2 can now destroy the memory mapping using munmap and release other resources.<pre><code class="language-c">Step 8 :close (sockfd);
/* No need to free linkedlist , we destroy the entire VM page */
munmap (vm_page_memory, vm_page_xmit_data-&gt;page_size);
free(buffer);</code></pre><h1 style="text-align: start" id="228f3ce9-2cf5-434a-b18e-468df6fa3315" data-toc-id="228f3ce9-2cf5-434a-b18e-468df6fa3315">Want to get access to our Full Courses?</h1>website <a target="_blank" rel="noopener noreferrer nofollow" class="af jq" href="http://www.csepracticals.com/">www.csepracticals.com</a>, We offer 25 Courses on System Programming, Operating Systems, Network Programming, and Development Projects.Telegram Grp (1k+ System Programming Engineers ): <a target="_blank" rel="noopener noreferrer nofollow" href="https://t.me/telecsepracticals">https://t.me/telecsepracticals</a>

copy-pasting the snapshot of the data structures kept in memory ( the data, and the pointer linkages between them ) into the RAM of the remote machine.

Cloning Data Structures to Remote Machine Transparently!

There are use cases when we need to replicate the data from one machine (origin) to a couple of other remote machines over the network.

Learn how to grow and scale your online course business using our online course platform. EzyCourse blog is designed to teach you how to create and sell online courses.

Cloning Data Structures to Remote Machine Transparently!

Cloning Data Structures to Remote Machine Transparently!

Related Posts

In What Order should one do CSEPracticals Courses