PHP giờ so với microtime

$curTime = microtime(true); . //php. net/thủ công/vi/chức năng. microtime. php) Hy vọng bạn sẽ áp dụng nó cho nhu cầu của mình

$curTime = microtime(true); . //php. net/thủ công/vi/chức năng. microtime. php) Hy vọng bạn sẽ áp dụng nó cho nhu cầu của mình

Giá trị trả về. Theo mặc định, microtime() trả về một chuỗi ở dạng "msec sec", trong đó sec là số giây kể từ Kỷ nguyên Unix (0. 00. 00 tháng 1, 1,1970 GMT) và msec đo micro giây đã trôi qua kể từ giây và cũng được biểu thị bằng giây

Hàm date_diff() trả về sự khác biệt giữa hai đối tượng DateTime

Chức năng này đặc biệt cần thiết trên các máy ảo chạy trên KVM, XEN (openstack, AWS EC2, v.v.) khi định thời gian thực thi. Trên những nền tảng thiếu vDSO này, phương pháp phổ biến là sử dụng time() hoặc microtime() có thể làm tăng đáng kể thời gian thực thi/CPU do bối cảnh chuyển từ vùng người dùng sang kernel khi chạy lệnh gọi hệ thống `gettimeofday()`

Valeurs de retour. Par défaut, microtime() retourne une chaîne de caractères au format "msec sec", où sec est le nombre de secondes depuis l'époque Unix (1 Janvier 1970, 00. 00. 00 GMT), et msec est le nombre de microsecondes qui se sont écoulées depuis sec, exprimé en seconds

microtime (PHP 4, PHP 5, PHP 7, PHP 8) Für Leistungsfähigkeitsmessungen wird die Verwendung von hrtime() empfohlen. Tham số-Liste. getAsFloat

Máy tính trực tuyến để chuyển đổi micro giây sang phút (µs sang min) với các công thức, ví dụ và bảng. Chuyển đổi của chúng tôi cung cấp một cách nhanh chóng và dễ dàng để chuyển đổi giữa các đơn vị Thời gian

PHPBench lấy mẫu thời gian để mã của bạn chạy. Trình thực thi mặc định thực hiện việc này bằng cách lặp lại mã của bạn một số lần (

    public function benchNoOp(): void
    {
    }

    /**
     * @ParamProviders({"provideSleep"})
     */
    public function benchSleep(array $params): void
    {
        usleep($params['sleep']);
    }

2) và chia tổng thời gian tính bằng micrô giây (i. e.

    public function benchNoOp(): void
    {
    }

    /**
     * @ParamProviders({"provideSleep"})
     */
    public function benchSleep(array $params): void
    {
        usleep($params['sleep']);
    }

4) theo số vòng quay để cung cấp phép đo thời gian (mẫu thời gian cho một

    public function benchNoOp(): void
    {
    }

    /**
     * @ParamProviders({"provideSleep"})
     */
    public function benchSleep(array $params): void
    {
        usleep($params['sleep']);
    }

7)

Điều này về cơ bản tóm tắt thành đoạn mã sau (tập lệnh lấy mẫu)

$start = microtime(true);
for ($r = 0; $r < $revs; $r++) {
    $yourBenchmark->callSubject();
}
$end = microtime(true);
$sampleTime = ( - $start) / $revs;

Quá trình này được lặp lại theo số lượng

    public function benchNoOp(): void
    {
    }

    /**
     * @ParamProviders({"provideSleep"})
     */
    public function benchSleep(array $params): void
    {
        usleep($params['sleep']);
    }

8 được chỉ định và từ những mẫu này, chúng tôi tính toán giá trị có thể xảy ra nhất (chế độ KDE)

Ban đầu, vòng lặp nhằm mục đích cung cấp kết quả tốt hơn với các điểm chuẩn vi mô (mã rất nhanh có thể hoàn thành trong chưa đầy một phần triệu giây) nhưng kể từ phiên bản 7. 3 (Tháng 11 năm 2018) PHP đã hỗ trợ

    public function benchNoOp(): void
    {
    }

    /**
     * @ParamProviders({"provideSleep"})
     */
    public function benchSleep(array $params): void
    {
        usleep($params['sleep']);
    }

3 cho phép bạn lấy mẫu thời gian hiện tại ở độ phân giải

+--------------+---------------------+-------+------------------+--------+------------+------+---------+----------+
| suite        | date                | php   | vcs branch       | xdebug | iterations | revs | mode    | net_time |
+--------------+---------------------+-------+------------------+--------+------------+------+---------+----------+
| microloop10  | 2021-12-18 21:36:31 | 8.1.0 | program-executor | false  | 110        | 1100 | 2.746ms | 18.801s  |
| hrtimeloop10 | 2021-12-18 21:37:00 | 8.1.0 | program-executor | false  | 110        | 1100 | 2.746ms | 18.797s  |
| microloop1   | 2021-12-18 21:30:10 | 8.1.0 | program-executor | false  | 110        | 110  | 2.746ms | 1.878s   |
| hrtimeloop1  | 2021-12-18 21:30:28 | 8.1.0 | program-executor | false  | 110        | 110  | 2.746ms | 1.878s   |
| hrtimenoloop | 2021-12-18 21:34:41 | 8.1.0 | program-executor | false  | 110        | 110  | 2.746ms | 1.878s   |
+--------------+---------------------+-------+------------------+--------+------------+------+---------+----------+

0

Mặc dù

    public function benchNoOp(): void
    {
    }

    /**
     * @ParamProviders({"provideSleep"})
     */
    public function benchSleep(array $params): void
    {
        usleep($params['sleep']);
    }

3 rõ ràng là một tính năng phù hợp với PHPBench nhưng tôi không có thời gian hoặc động lực để cấu trúc lại PHPBench để phù hợp với nó - đặc biệt là vì tôi không nghĩ rằng nó sẽ mang lại lợi thế đáng kể cho phần lớn các trường hợp

Vòng lặp tạo ra sự khác biệt gì? . )

Cài đặt ¶

Điểm chuẩn của chúng tôi trước hết sẽ chạy một phương thức trống, sau đó chạy một phương thức đang ngủ sẽ ngủ trong thời gian tăng dần

    public function benchNoOp(): void
    {
    }

    /**
     * @ParamProviders({"provideSleep"})
     */
    public function benchSleep(array $params): void
    {
        usleep($params['sleep']);
    }

Giấc ngủ đóng vai trò như một mỏ neo mà chúng ta có thể so sánh các phép đo của PHPBench

Tất cả các điểm chuẩn đã được thực hiện với PHP8. 1 khi tắt Xdebug, tổng quan như sau

+--------------+---------------------+-------+------------------+--------+------------+------+---------+----------+
| suite        | date                | php   | vcs branch       | xdebug | iterations | revs | mode    | net_time |
+--------------+---------------------+-------+------------------+--------+------------+------+---------+----------+
| microloop10  | 2021-12-18 21:36:31 | 8.1.0 | program-executor | false  | 110        | 1100 | 2.746ms | 18.801s  |
| hrtimeloop10 | 2021-12-18 21:37:00 | 8.1.0 | program-executor | false  | 110        | 1100 | 2.746ms | 18.797s  |
| microloop1   | 2021-12-18 21:30:10 | 8.1.0 | program-executor | false  | 110        | 110  | 2.746ms | 1.878s   |
| hrtimeloop1  | 2021-12-18 21:30:28 | 8.1.0 | program-executor | false  | 110        | 110  | 2.746ms | 1.878s   |
| hrtimenoloop | 2021-12-18 21:34:41 | 8.1.0 | program-executor | false  | 110        | 110  | 2.746ms | 1.878s   |
+--------------+---------------------+-------+------------------+--------+------------+------+---------+----------+

Thời gian đo được nhỏ nhất ¶

PHPbench muốn giảm thiểu chi phí liên quan đến việc thực hiện phép đo, thời gian tối thiểu tuyệt đối mà chúng tôi có thể đo trong PHP là bao nhiêu?

Tập lệnh sau đây so sánh

    public function benchNoOp(): void
    {
    }

    /**
     * @ParamProviders({"provideSleep"})
     */
    public function benchSleep(array $params): void
    {
        usleep($params['sleep']);
    }

4 (micro giây) và

    public function benchNoOp(): void
    {
    }

    /**
     * @ParamProviders({"provideSleep"})
     */
    public function benchSleep(array $params): void
    {
        usleep($params['sleep']);
    }

3 (nano giây được chia tỷ lệ thành micro giây)

    public function benchNoOp(): void
    {
    }

    /**
     * @ParamProviders({"provideSleep"})
     */
    public function benchSleep(array $params): void
    {
        usleep($params['sleep']);
    }

3

sản xuất

    public function benchNoOp(): void
    {
    }

    /**
     * @ParamProviders({"provideSleep"})
     */
    public function benchSleep(array $params): void
    {
        usleep($params['sleep']);
    }

4

Vì vậy, chúng ta có thể thấy rằng

    public function benchNoOp(): void
    {
    }

    /**
     * @ParamProviders({"provideSleep"})
     */
    public function benchSleep(array $params): void
    {
        usleep($params['sleep']);
    }

4 không có khả năng đo khoảng thời gian tối thiểu vì nó nhỏ hơn 1 micro giây. Chúng tôi cũng thấy rằng phải mất 2-4 lần lặp lại để trình lấy mẫu

    public function benchNoOp(): void
    {
    }

    /**
     * @ParamProviders({"provideSleep"})
     */
    public function benchSleep(array $params): void
    {
        usleep($params['sleep']);
    }

3 ổn định

Lần đầu tiên tôi làm điều này, thời gian tối thiểu có thể đo được là 20μs. Sau khi khởi động lại máy tính của tôi, nó là 0. 27 như trên và sau đó tôi phải viết lại bài đăng này 😕 Tuy nhiên, điều này không ảnh hưởng đến các phép đo > 20μs

Microtime vs. Giờ với 10 vòng quay ¶

Điều này so sánh bộ thực thi microtime ban đầu và bộ thực thi

    public function benchNoOp(): void
    {
    }

    /**
     * @ParamProviders({"provideSleep"})
     */
    public function benchSleep(array $params): void
    {
        usleep($params['sleep']);
    }

3 mới với 10 vòng quay, tôi. e

    public function benchNoOp(): void
    {
    }

    /**
     * @ParamProviders({"provideSleep"})
     */
    public function benchSleep(array $params): void
    {
        usleep($params['sleep']);
    }

8

Kết quả

    public function benchNoOp(): void
    {
    }

    /**
     * @ParamProviders({"provideSleep"})
     */
    public function benchSleep(array $params): void
    {
        usleep($params['sleep']);
    }

9

Ở trên, chúng ta thấy rằng thời gian không hoạt động được ghi lại bằng

    public function benchNoOp(): void
    {
    }

    /**
     * @ParamProviders({"provideSleep"})
     */
    public function benchSleep(array $params): void
    {
        usleep($params['sleep']);
    }

3, mặc dù nó dường như bị vòng lặp loại bỏ gần như hoàn toàn

Ngoài no-op, dường như không có sự khác biệt giữa người thi hành

    public function benchNoOp(): void
    {
    }

    /**
     * @ParamProviders({"provideSleep"})
     */
    public function benchSleep(array $params): void
    {
        usleep($params['sleep']);
    }

4 và

    public function benchNoOp(): void
    {
    }

    /**
     * @ParamProviders({"provideSleep"})
     */
    public function benchSleep(array $params): void
    {
        usleep($params['sleep']);
    }

3

Microtime vs. Giờ với 1 vòng quay ¶

Tương tự như trên nhưng chỉ trong 1 vòng lặp, tập lệnh giống như

    public function benchNoOp(): void
    {
    }

    /**
     * @ParamProviders({"provideSleep"})
     */
    public function benchSleep(array $params): void
    {
        usleep($params['sleep']);
    }

3

Và kết quả

    public function benchNoOp(): void
    {
    }

    /**
     * @ParamProviders({"provideSleep"})
     */
    public function benchSleep(array $params): void
    {
        usleep($params['sleep']);
    }

4

Vòng lặp

    public function benchNoOp(): void
    {
    }

    /**
     * @ParamProviders({"provideSleep"})
     */
    public function benchSleep(array $params): void
    {
        usleep($params['sleep']);
    }

3 được tăng lên nhưng kết quả vẫn giữ nguyên với 1 vòng quay/vòng lặp

Giờ không có vòng lặp ¶

Trình thực thi mới cho phép bạn xác định cách xây dựng tập lệnh. Hãy loại bỏ hoàn toàn vòng lặp

    public function benchNoOp(): void
    {
    }

    /**
     * @ParamProviders({"provideSleep"})
     */
    public function benchSleep(array $params): void
    {
        usleep($params['sleep']);
    }

32

    public function benchNoOp(): void
    {
    }

    /**
     * @ParamProviders({"provideSleep"})
     */
    public function benchSleep(array $params): void
    {
        usleep($params['sleep']);
    }

7

Chúng tôi thấy thời gian không hoạt động giảm đi một chút như chúng tôi có thể mong đợi bằng cách loại bỏ vòng lặp for

So sánh thuật toán băm 10 vòng quay ¶

So sánh các thuật toán băm khác nhau bằng cách sử dụng hai bộ thực thi khác nhau, chúng ta có thể thấy rằng

    public function benchNoOp(): void
    {
    }

    /**
     * @ParamProviders({"provideSleep"})
     */
    public function benchSleep(array $params): void
    {
        usleep($params['sleep']);
    }

3 có nhiều sắc thái hơn

    public function benchNoOp(): void
    {
    }

    /**
     * @ParamProviders({"provideSleep"})
     */
    public function benchSleep(array $params): void
    {
        usleep($params['sleep']);
    }

0

So sánh thuật toán băm 1 vs. không có số vòng quay ¶

So sánh các thuật toán băm khác nhau bằng cách sử dụng hai bộ thực thi khác nhau, chúng ta có thể thấy rằng

    public function benchNoOp(): void
    {
    }

    /**
     * @ParamProviders({"provideSleep"})
     */
    public function benchSleep(array $params): void
    {
        usleep($params['sleep']);
    }

3 có nhiều sắc thái hơn

    public function benchNoOp(): void
    {
    }

    /**
     * @ParamProviders({"provideSleep"})
     */
    public function benchSleep(array $params): void
    {
        usleep($params['sleep']);
    }

1

Với cả vòng lặp đơn và không vòng lặp, chúng tôi thấy thời gian tăng lên rất nhiều

Kết luận ¶

Như mong đợi,

    public function benchNoOp(): void
    {
    }

    /**
     * @ParamProviders({"provideSleep"})
     */
    public function benchSleep(array $params): void
    {
        usleep($params['sleep']);
    }

3 mang lại độ chính xác cao hơn trong khoảng thời gian cực ngắn. Tuy nhiên, việc thực hiện chủ đề lặp đi lặp lại trong một vòng lặp sẽ bình thường hóa độ chính xác giữa

    public function benchNoOp(): void
    {
    }

    /**
     * @ParamProviders({"provideSleep"})
     */
    public function benchSleep(array $params): void
    {
        usleep($params['sleep']);
    }

4 và

    public function benchNoOp(): void
    {
    }

    /**
     * @ParamProviders({"provideSleep"})
     */
    public function benchSleep(array $params): void
    {
        usleep($params['sleep']);
    }

3

Nhưng bài đăng này đặt câu hỏi nếu, với sự ra đời của

    public function benchNoOp(): void
    {
    }

    /**
     * @ParamProviders({"provideSleep"})
     */
    public function benchSleep(array $params): void
    {
        usleep($params['sleep']);
    }

3, sẽ không hợp lý nếu đưa ra một tùy chọn để chạy mà không có vòng lặp, tôi. e.

    public function benchNoOp(): void
    {
    }

    /**
     * @ParamProviders({"provideSleep"})
     */
    public function benchSleep(array $params): void
    {
        usleep($params['sleep']);
    }

39 không có vòng lặp và không có khả năng PHP tối ưu hóa mã và do đó đưa ra một báo cáo có khả năng gây hiểu nhầm

Hrtime PHP là gì?

Microtime PHP là gì?