Imagen de proceso de superposición

Supongamos que estamos ejecutando un programa y queremos ejecutar otro programa del programa actual. es posible? Por qué no, si implementamos el concepto de superposición de la imagen del proceso. Eso está bien, pero ¿qué pasa con el programa en ejecución actual? ¿Se puede ejecutar también? ¿Cómo es posible, ya que superpusimos el programa actual con el nuevo programa? ¿Qué hacer, si quiero ejecutar los dos programas sin perder el programa en ejecución actual, es posible? Sí, es posible.

Cree un proceso hijo, de modo que tengamos un proceso padre y un proceso hijo recién creado. Ya estamos ejecutando el programa actual en el proceso padre, así que ejecute el proceso recién creado en el hijo. De esta forma, podemos ejecutar otro programa del programa actual. No solo un solo programa, sino que podemos ejecutar cualquier número de programas del programa actual creando esa cantidad de procesos secundarios.

Consideremos el siguiente programa como ejemplo.

/ * Nombre de archivo: helloworld.c * /

#include<stdio.h>

void main() {
   printf("Hello World\n");
   return;
}

/ * Nombre de archivo: execl_test.c * /

#include<stdio.h>
#include<unistd.h>

void main() {
   execl("./helloworld", "./helloworld", (char *)0);
   printf("This wouldn't print\n");
   return;
}

El programa anterior superpondría la imagen de proceso de execl_test con helloworld. Esa es la razón por la que el código de imagen de proceso de execl_test (printf ()) no se ejecuta.

Pasos de compilación y ejecución

Hello World

Ahora, ejecutaremos los siguientes dos programas desde un programa, es decir, execl_run_two_prgms.c.

Programa Hola mundo (helloworld.c)
Programa de ciclo while para imprimir de 1 a 10 (while_loop.c)

/ * Nombre de archivo: while_loop.c * /

/* Prints numbers from 1 to 10 using while loop */
#include<stdio.h>

void main() {
   int value = 1;
   while (value <= 10) {
      printf("%d\t", value);
      value++;
   }
   printf("\n");
   return;
}

A continuación se muestra el programa para ejecutar dos programas (un programa del niño y otro programa del padre).

/ * Nombre de archivo: execl_run_two_prgms.c * /

#include<stdio.h>
#include<unistd.h>

void main() {
   int pid;
   pid = fork();
   
   /* Child process */
   if (pid == 0) {
      printf("Child process: Running Hello World Program\n");
      execl("./helloworld", "./helloworld", (char *)0);
      printf("This wouldn't print\n");
   } else { /* Parent process */
      sleep(3);
      printf("Parent process: Running While loop Program\n");
      execl("./while_loop", "./while_loop", (char *)0);
      printf("Won't reach here\n");
   }
   return;
}

Note - Realice una llamada a sleep () para asegurarse de que los procesos hijo y padre se ejecuten secuencialmente (no superpongan el resultado).

Pasos de compilación y ejecución

Child process: Running Hello World Program
This wouldn't print
Parent process: Running While loop Program
Won't reach here

Ahora ejecutaríamos dos programas desde un programa, es decir, execl_run_two_prgms.c, el mismo programa que el anterior pero con argumentos de línea de comando. Entonces, estamos ejecutando dos programas, a saber, helloworld.c en el proceso hijo y el programa while_loop.c en el proceso padre. Esto es como sigue:

Programa Hola mundo (helloworld.c)
Programa de ciclo while para imprimir de 1 a num_times_str según los argumentos de la línea de comando (while_loop.c)

Este programa realiza en general las siguientes acciones:

Crea un proceso hijo
El proceso hijo ejecuta el programa helloworld.c
El proceso padre ejecuta el programa while_loop.c pasando el valor del argumento de la línea de comandos como un argumento al programa. Si no se pasan los argumentos de la línea de comando, el valor predeterminado se toma como 10. De lo contrario, toma el valor del argumento dado. El valor del argumento debe ser numérico; el código no se validaría si se proporciona en alfabetos.

/ * Nombre de archivo: execl_run_two_prgms.c * /

#include<stdio.h>
#include<string.h>
#include<unistd.h>

void main(int argc, char *argv[0]) {
   int pid;
   int err;
   int num_times;
   char num_times_str[5];
   
   /* In no command line arguments are passed, then loop maximum count taken as 10 */
   if (argc == 1) {
      printf("Taken loop maximum as 10\n");
      num_times = 10;
      sprintf(num_times_str, "%d", num_times);
   } else {
      strcpy(num_times_str, argv[1]);
      printf("num_times_str is %s\n", num_times_str);
      pid = fork();
   }
   
   /* Child process */
   if (pid == 0) {
      printf("Child process: Running Hello World Program\n");
      err = execl("./helloworld", "./helloworld", (char *)0);
      printf("Error %d\n", err);
      perror("Execl error: ");
      printf("This wouldn't print\n");
   } else { /* Parent process */
      sleep(3);
      printf("Parent process: Running While loop Program\n");
      execl("./while_loop", "./while_loop", (char *)num_times_str, (char *)0);
      printf("Won't reach here\n");
   }
   return;
}

A continuación se muestra el programa helloworld.c llamado desde el proceso hijo del programa, execl_run_two_prgms.c.

/ * Nombre de archivo: helloworld.c * /

#include<stdio.h>

void main() {
   printf("Hello World\n");
   return;
}

A continuación se muestra el programa while_loop.c llamado desde el proceso principal del programa, execl_run_two_prgms.c. El argumento de este programa se pasa desde el programa que ejecuta esto, es decir, execl_run_two_prgms.c.

/ * Nombre de archivo: while_loop.c * /

#include<stdio.h>

void main(int argc, char *argv[]) {
   int start_value = 1;
   int end_value;
   if (argc == 1)
   end_value = 10;
   else
   end_value = atoi(argv[1]);
   printf("Argv[1] is %s\n", argv[1]);
   while (start_value <= end_value) {
      printf("%d\t", start_value);
      start_value++;
   }
   printf("\n");
   return;
}

Pasos de compilación y ejecución

Taken loop maximum as 10
num_times_str is 10
Child process: Running Hello World Program
Hello World
Parent process: Running While loop Program
Argv[1] is 10
1 2 3 4 5 6 7 8 9 10
Taken loop maximum as 15
num_times_str is 15
Child process: Running Hello World Program
Hello World
Parent process: Running While loop Program
Argv[1] is 15
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Veamos ahora las funciones de biblioteca relacionadas con imágenes superpuestas.

#include<unistd.h>

int execl(const char *path, const char *arg, ...);

Esta función superpondría la imagen del proceso en ejecución actual con el nuevo proceso como se menciona en los argumentos, ruta y arg. Si algún argumento necesita pasar a una nueva imagen de proceso, se enviará a través de argumentos "arg" y el último argumento debería ser NULL.

Esta función devolvería un valor solo en caso de error. El proceso que superpone las llamadas relacionadas con la imagen es el que se menciona a continuación:

int execl(const char *path, const char *arg, ...);
int execlp(const char *file, const char *arg, ...);
int execle(const char *path, const char *arg, ..., char * const envp[]);
int execv(const char *path, char *const argv[]);
int execvp(const char *file, char *const argv[]);
int execvpe(const char *file, char *const argv[], char *const envp[]);

Estas llamadas abordarían el paso de argumentos de línea de comandos (argv []), variables de entorno (envp []) y otros parámetros.

↰ Previous page Next page ↱