Development Techniques for Migrating Embedded SoC Multi-threaded Architecture to Multi-process Architecture

• Complex shared resource management: Threads sharing memory can easily lead to data races and resource conflicts, especially when lock mechanisms are misused.

• High impact of crashes: If one thread crashes, the entire process is affected, leading to system instability.

• Difficult debugging: Debugging memory issues and thread synchronization problems is complex due to shared state among threads.

• Enhanced stability: A crash in one process does not affect other processes, making the system more resilient.

• Resource isolation: Different processes are independent of each other, reducing data race issues.

• Improved security: Different processes can run under different permissions, enhancing system security.

• Data collection process: Specifically handles sensor data collection.

• Data processing process: Performs data analysis and processing.

• Communication process: Responsible for communication with external devices or servers.

• User interface process: Interacts with the user.

• Message queues: Suitable for passing short messages, with a priority mechanism.

• Shared memory: Used for efficient transmission of large amounts of data, but requires additional synchronization control.

• Semaphores: Used to synchronize operations between processes, ensuring orderly execution.

• Pipes: Unidirectional communication channels suitable for data transmission between parent and child processes.

• Sockets: Used for communication between different devices or across networks.

The use of multi-process architecture in embedded systems may increase memory and resource overhead since each process has its own independent address space and resources.

To optimize performance, consider using lightweight IPC mechanisms or adjusting the number and distribution of processes according to needs.

Besides shared memory, inter-process communication can also use message queues, pipes, or sockets, choosing the most suitable method based on actual needs.

Although shared memory is efficient for large data transfers, it requires synchronization handling (e.g., using semaphores) to avoid concurrent access conflicts.

The multi-process architecture greatly enhances the isolation of the system.

If a process crashes, other processes can continue to work normally, improving system stability.

By monitoring the status of child processes from the parent process, automatic restart functionality can be implemented in case of crashes, further enhancing the system’s fault tolerance.

• Temperature sensor data collection thread.

• Data processing thread.

• Communication module thread, which sends processed data to a remote server.

// Global shared variablefloat temperature_data = 0.0; // Simulate reading temperature sensor datafloat read_temperature_sensor() { return 25.0 + (rand() % 10); // Randomly simulate temperature} // Simulate processing datavoid process_temperature_data(float temp) { printf("Processing temperature data: %.2f\n", temp); sleep(1); // Simulate data processing time} // Simulate sending data to servervoid send_data_over_network(float temp) { printf("Sending data over network: %.2f\n", temp); sleep(1); // Simulate network communication time} // Temperature collection threadvoid* temperature_thread(void* arg) { while (1) { temperature_data = read_temperature_sensor(); printf("Temperature read: %.2f\n", temperature_data); sleep(2); // Simulate collection period } return NULL; } // Data processing threadvoid* processing_thread(void* arg) { while (1) { process_temperature_data(temperature_data); } return NULL; } // Communication threadvoid* communication_thread(void* arg) { while (1) { send_data_over_network(temperature_data); } return NULL; } int main() { pthread_t temp_thread, proc_thread, comm_thread; // Create three threads pthread_create(&temp_thread, NULL, temperature_thread, NULL); pthread_create(&proc_thread, NULL, processing_thread, NULL); pthread_create(&comm_thread, NULL, communication_thread, NULL); // Wait for threads to complete pthread_join(temp_thread, NULL); pthread_join(proc_thread, NULL); pthread_join(comm_thread, NULL); return 0;}

• Data races: Multiple threads accessing and modifying the same global variable temperature_data can easily lead to data races.

• Stability: If one thread crashes, the entire process will terminate.

• Difficult debugging: Debugging memory issues is complex due to shared resources among threads.

Use ftok() to generate a unique key to identify the shared memory.

shmget() creates a shared memory segment, specifying the size of the shared memory as sizeof(float) to store temperature data.

shmat() maps the shared memory to the process’s address space, allowing each child process to access this shared memory.

Use fork() to create three child processes, each responsible for temperature data collection, data processing, and data sending.

Each child process has its own independent memory space but exchanges data through shared memory.

Temperature collection process: Responsible for reading sensor data and writing data into shared memory’s temperature_data.

Data processing process: Reads temperature data from shared memory and performs corresponding processing operations.

Communication process: Reads processed data from shared memory and sends it over the network to a remote server.

The parent process uses the wait() function to wait for the execution of child processes to end, ensuring all child processes run correctly.

When the system terminates, the parent process will detach and delete the shared memory to prevent memory leaks.

// Simulate reading temperature sensor datafloat read_temperature_sensor() { return 25.0 + (rand() % 10); // Randomly simulate temperature} // Simulate processing datavoid process_temperature_data(float temp) { printf("Processing temperature data: %.2f\n", temp); sleep(1); // Simulate data processing time} // Simulate sending data to servervoid send_data_over_network(float temp) { printf("Sending data over network: %.2f\n", temp); sleep(1); // Simulate network communication time} int main() { // Create shared memory segment key_t key = ftok("shmfile", 65); // Generate shared memory key int shmid = shmget(key, sizeof(float), 0666 | IPC_CREAT); // Create shared memory float *temperature_data = (float *) shmat(shmid, NULL, 0); // Map shared memory to process address space // Parent process creates child processes pid_t pid = fork(); if (pid == 0) { // Child process 1: responsible for temperature collection while (1) { *temperature_data = read_temperature_sensor(); printf("Temperature read: %.2f\n", *temperature_data); sleep(2); // Simulate collection period } } else { pid_t pid2 = fork(); if (pid2 == 0) { // Child process 2: responsible for data processing while (1) { process_temperature_data(*temperature_data); } } else { pid_t pid3 = fork(); if (pid3 == 0) { // Child process 3: responsible for data sending while (1) { send_data_over_network(*temperature_data); } } else { // Parent process: wait for all child processes wait(NULL); // Wait for the first child process to finish wait(NULL); // Wait for the second child process to finish wait(NULL); // Wait for the third child process to finish // Detach and delete shared memory shmdt(temperature_data); shmctl(shmid, IPC_RMID, NULL); } } } return 0;}