如何在C中以较低的时钟速度运行程序

Question

我需要模仿硬件的工作原理（不适用于视频游戏）。

此组件以1 Ghz运行，而我的PC以2.5和2.7 Ghz运行。

所以我试图告诉电脑以较低的速度运行这个特定的过程。

我已经尝试过定时器，但它不会这样做：当处理很小的时间间隔时，过程将无法准确跟踪时间（我需要跟踪毫秒并且无法完成整齐） 另外，为了计算时间间隔，你会耗费一些CPU时间

请记住，我不是外包给社区，我正在自己工作，但也许你们可以帮助头脑风暴：）

Answer 1

前提

从我的问题中了解到的＆amp;注释，您需要在12.5 Hz CPU上运行程序。我可以想到单步执行指令，就像调试器一样，但不是等你单步执行指令，而是在每个时间延迟执行每条指令（就像你说的那样你尝试过） ）。 所以，如果这个前提是错误的，请告诉我，我会删除我的答案，因为它是基于它的。

想法

如果您的时钟计数为80ms，则表示您可以按80ms执行至少一条指令。不幸的是，sleep函数只会在秒中获取unsigned int个参数，因此无法正常工作。但是，系统调用nanosleep可让您调整nanoseconds中的睡眠状态。

因此，要将毫秒转换为纳米，您将其乘以10 ⁶ ，这将为您提供80000000 nanoseconds的睡眠时间。正如您已经提到的那样，函数调用和模拟器时间会浪费一些时间，但我认为这是您为模拟器付出的代价（并且您可以随时修补时间< / em>进行更精细的调整）。所以，nanosleep是：

#include <time.h>

int nanosleep(const struct timespec *req, struct timespec *rem);

struct timespec {
       time_t tv_sec;        /* seconds */
       long   tv_nsec;       /* nanoseconds */
};

另一个是Linux系统调用ptrace

#include <sys/ptrace.h>

long ptrace(enum __ptrace_request request, pid_t pid,
               void *addr, void *data);

此功能可让您使用跟踪过程执行各种操作，建议您阅读本手册。它非常有说服力。该系统调用是调试软件的基本功能，您可以在此处阅读How Debuggers Work的教程。

事实上，我的想法来自那个教程（我几天前读过），我会稍微修改一下代码来做模拟器，所以我也建议阅读教程。

代码

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

#include <time.h>
#include <sys/ptrace.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/reg.h>
#include <sys/user.h>

#define MILLI       80
#define HZ      ((double)1000/(double)MILLI)

/* milli to nano */
#define m2n(a)      (a*1000*1000) 

void run_target(char *prog)
{
    printf("Emulating %.2lf Hz to proccess %s...\n\n", HZ, prog);

    if (ptrace(PTRACE_TRACEME, 0, 0, 0) < 0) {
        perror("ptrace");
        return ;
    }

    execl(prog, prog, (char*)NULL);
}

void run_emulator(pid_t child)
{
    int wait_status;
    struct timespec req;
    unsigned long int count = 1;

    /* set up the emulation speed */
    req.tv_sec = 0;
    req.tv_nsec = m2n(MILLI);

    /* wait for stop on first instruction */
    wait(&wait_status);
    while (WIFSTOPPED(wait_status)) {
        /* this loop will repeat at every instruction, so it executes the
         * instruction and sleeps for the amount of time needed to 
         * emulate the wanted speed.
         */
        if (ptrace(PTRACE_SINGLESTEP, child, 0, 0) < 0) {
            perror("ptrace");
            return ;
        }
        wait(&wait_status);

        /* this does the sleep */
        nanosleep(&req, NULL);
    }
}

int main(int argc, char *argv[])
{
    pid_t child;

    if (argc < 2) {
        fprintf(stderr, "Usage: %s [prog_name]\n", argv[0]);
        exit(EXIT_FAILURE);
    }

    child = fork();

    if (!child)
        run_target(argv[1]);
    else if (child > 0)
        run_emulator(child);
    else {
        perror("fork");
        exit(EXIT_FAILURE);
    }

    return 0;
}

为了进行快速测试，我在Assembly中编写了这个简单的fat(5)计算器，它有65条指令（当然在我的机器上）：

 .section .data
 .section .text
 .globl _start
 .globl factorial
_start:

 pushq  $5
 call   factorial
 movq   %rax, %rdi
 movq   $0x3c, %rax
 syscall

 .type factorial, @function
factorial:
 pushq  %rbp        
 movq   %rsp, %rbp  
 movq   16(%rbp), %rax  
 cmpq   $1, %rax        
 je     end_factorial   
 decq   %rax
 pushq  %rax        
 call   factorial
 movq   16(%rbp), %rbx  
 imulq  %rbx, %rax

end_factorial:
 movq   %rbp, %rsp  
 popq   %rbp
 ret

汇编，链接，运行和查看结果：

$ as -o fat.o fat.s
$ ld -o fat fat.o
$ ./fat 
$ echo $?
120
$

因此，它可以工作并计算5的阶乘。因此，如果我在数学上正确，65条指令将花费65/12.5秒在12.5Hz CPU上运行，对吧？ 65/12.5 = 5.2。

$ time ./lower ./fat
Emulating 12.50 Hz to proccess ./fat...

Returned: 30720

real    0m5.211s
user    0m0.000s
sys 0m0.008s

手动参考

• wait
• ptrace
• nanosleep