小实验记录

#include <stdio.h>

int main(void)
{
	puts("hello world");
	return 0;
}

int main(void)
{
	for (;;)
		;
}

#include <sys/types.h>
#include <unistd.h>

int main(void)
{
	for (;;)
		getppid();
}

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

static void child()
{
	printf("I'm child! my pid is %d.\n", getpid());
	exit(EXIT_SUCCESS);
}

static void parent(pid_t pid_c)
{
	printf("I'm parent! my pid is %d and the pid of my child is %d.\n",
	       getpid(), pid_c);
	exit(EXIT_SUCCESS);
}

int main(void)
{
	pid_t ret;
	ret = fork();
	if (ret == -1)
		err(EXIT_FAILURE, "fork() failed");
	if (ret == 0) {
		// fork() 会返回 0 给子进程，因此这里调用 child()
		child();
	} else {
		// fork() 会返回新创建的子进程的进程 ID（大于 1）给父进程，因此这里调用 parent()
		parent(ret);
	}
	// 在正常运行时，不可能运行到这里
	err(EXIT_FAILURE, "shouldn't reach here");
}

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

static void child()
{
	char *args[] = { "/bin/echo", "hello" , NULL};
	printf("I'm child! my pid is %d.\n", getpid());
	fflush(stdout);
	execve("/bin/echo", args, NULL);
	err(EXIT_FAILURE, "exec() failed");
}

static void parent(pid_t pid_c)
{
	printf("I'm parent! my pid is %d and the pid of my child is %d.\n",
	       getpid(), pid_c);
	exit(EXIT_SUCCESS);
}

int main(void)
{
	pid_t ret;
	ret = fork();
	if (ret == -1)
		err(EXIT_FAILURE, "fork() failed");
	if (ret == 0) {
		// fork() 会返回 0 给子进程，因此这里调用 child()
		child();
	} else {
		// fork() 会返回新创建的子进程的进程 ID（大于 1）给父进程，因此这里调用 parent()
		parent(ret);
	}
	// 在正常运行时，不可能运行到这里
	err(EXIT_FAILURE, "shouldn't reach here");
}

#include <sys/types.h>
#include <sys/wait.h>
#include <time.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <err.h>

#define NLOOP_FOR_ESTIMATION 1000000000UL
#define NSECS_PER_MSEC 1000000UL
#define NSECS_PER_SEC 1000000000UL

static unsigned long nloop_per_resol;
static struct timespec start;

// 计算两个timespec值之间的差值（以纳秒为单位）
static inline long diff_nsec(struct timespec before, struct timespec after)
{
    return ((after.tv_sec * NSECS_PER_SEC + after.tv_nsec) - (before.tv_sec * NSECS_PER_SEC + before.tv_nsec));
}

// 估计执行一个毫秒所需的循环迭代次数
static unsigned long estimate_loops_per_msec()
{
    struct timespec before, after;
    clock_gettime(CLOCK_MONOTONIC, &before);

    unsigned long i;
    for (i = 0; i < NLOOP_FOR_ESTIMATION; i++)
        ; // 空循环以消耗一定时间

    clock_gettime(CLOCK_MONOTONIC, &after);

    int ret;
    return NLOOP_FOR_ESTIMATION * NSECS_PER_MSEC / diff_nsec(before, after);
}

// 模拟一些CPU负载，通过执行循环迭代
static inline void load(void)
{
    unsigned long i;
    for (i = 0; i < nloop_per_resol; i++)
        ; // 循环迭代以模拟CPU负载
}

// 每个子进程执行的函数
static void child_fn(int id, struct timespec *buf, int nrecord)
{
    int i;
    for (i = 0; i < nrecord; i++)
    {
        struct timespec ts;

        load(); // 模拟一些CPU负载
        clock_gettime(CLOCK_MONOTONIC, &ts); // 记录当前时间
        buf[i] = ts;
    }
    for (i = 0; i < nrecord; i++)
    {
        // 打印子进程ID、从开始到当前时间的时间差（以毫秒为单位）以及完成百分比
        printf("%d\t%ld\t%d\n", id, diff_nsec(start, buf[i]) / NSECS_PER_MSEC, (i + 1) * 100 / nrecord);
    }
    exit(EXIT_SUCCESS); // 终止子进程
}

static pid_t *pids;

int main(int argc, char *argv[])
{
    int ret = EXIT_FAILURE;

    if (argc < 4)
    {
        fprintf(stderr, "usage: %s <nproc> <total[ms]> <resolution[ms]>\n", argv[0]);
        exit(EXIT_FAILURE);
    }

    int nproc = atoi(argv[1]);  //同时运行的程序数量  1、2、4
    int total = atoi(argv[2]);  //程序运行的总时长  100、100、100
    int resol = atoi(argv[3]);  //采集统计信息的间隔  1、1、1

    if (nproc < 1)
    {
        fprintf(stderr, "<nproc>(%d) should be >= 1\n", nproc);
        exit(EXIT_FAILURE);
    }

    if (total < 1)
    {
        fprintf(stderr, "<total>(%d) should be >= 1\n", total);
        exit(EXIT_FAILURE);
    }

    if (resol < 1)
    {
        fprintf(stderr, "<resol>(%d) should be >= 1\n", resol);
        exit(EXIT_FAILURE);
    }

    if (total % resol)
    {
        fprintf(stderr, "<total>(%d) should be multiple of <resolution>(%d)\n", total, resol);
        exit(EXIT_FAILURE);
    }
    int nrecord = total / resol; // 每个进程要创建的记录数

    struct timespec *logbuf = malloc(nrecord * sizeof(struct timespec));
    if (!logbuf)
        err(EXIT_FAILURE, "failed to allocate log buffer");

    puts("estimating the workload which takes just one milli-second...");
    nloop_per_resol = estimate_loops_per_msec() * resol; // 计算每个resolution所需的循环次数
    puts("end estimation");
    fflush(stdout);

    pids = malloc(nproc * sizeof(pid_t));
    if (pids == NULL)
        err(EXIT_FAILURE, "failed to allocate pid table");

    clock_gettime(CLOCK_MONOTONIC, &start); // 记录开始时间

    ret = EXIT_SUCCESS;
    int i, ncreated;
    for (i = 0, ncreated = 0; i < nproc; i++, ncreated++)
    {
        pids[i] = fork(); // 创建子进程
        if (pids[i] < 0)
        {
            int j;
            for (j = 0; j < ncreated; j++)
                kill(pids[j], SIGKILL); // 如果fork失败，kill创建的所有子进程
            ret = EXIT_FAILURE;
            break;
        }
        else if (pids[i] == 0)
        {
            // 子进程
            child_fn(i, logbuf, nrecord); // 执行子进程函数
            /* 不应该运行到这里 */
            abort(); // 这应该永远不会被执行；在出现错误时中止
        }
    }
    // 父进程
    for (i = 0; i < ncreated; i++)
    {
        if (wait(NULL) < 0)
            warn("wait() failed."); // 等待所有子进程完成
    }

    exit(ret); // 以适当的退出状态终止主进程
}