PolarDB:Pengumpulan sampah selama jam sepi

Konfigurasikan informasi jam sepi

1. Buat plugin.

   Anda harus membuat ekstensi polar_advisor pada database postgres dan pada semua database tempat Anda perlu melakukan pengumpulan sampah.

   CREATE EXTENSION IF NOT EXISTS polar_advisor;

   Untuk kluster PolarDB yang sudah memiliki ekstensi polar_advisor terpasang, jalankan perintah berikut untuk memperbaruinya:

   ALTER EXTENSION polar_advisor UPDATE;

2. Tetapkan jendela waktu.

   Jalankan perintah berikut untuk menetapkan periode jam sepi.

   -- Jalankan pada database postgres.
   SELECT polar_advisor.set_advisor_window(start_time, end_time);

   • start_time: Waktu mulai jendela.

   • end_time: Waktu selesai jendela.

   • Secara default, jendela berlaku pada hari yang sama. Pengumpulan sampah kemudian dilakukan secara otomatis dalam jendela waktu ini setiap hari.

   Catatan

   • Hanya jendela waktu yang dikonfigurasi di database postgres yang berlaku. Menetapkan jendela waktu di database lain tidak berpengaruh.

   • Offset zona waktu dalam waktu jendela harus konsisten dengan pengaturan zona waktu kluster PolarDB. Jika tidak, jendela waktu tidak berlaku.

   Contoh berikut menetapkan periode jam sepi dari pukul 23.00 hingga 02.00 setiap hari di zona waktu UTC+8. Kluster melakukan pengumpulan sampah selama periode ini setiap hari:

   SELECT polar_advisor.set_advisor_window(start_time => '23:00:00+08', end_time => '02:00:00+08');

3. Lihat jendela waktu.

   Jalankan perintah berikut untuk melihat informasi tentang periode jam sepi yang telah dikonfigurasi.

   -- Jalankan pada database postgres.
   
   -- Lihat detail periode jam sepi.
   SELECT * FROM polar_advisor.get_advisor_window();
   -- Lihat durasi periode jam sepi dalam detik.
   SELECT polar_advisor.get_advisor_window_length();
   -- Periksa apakah waktu saat ini berada dalam periode jam sepi.
   SELECT now(), * FROM polar_advisor.is_in_advisor_window();
   -- Lihat waktu tersisa hingga periode jam sepi berikutnya dimulai, dalam detik.
   SELECT * FROM polar_advisor.get_secs_to_advisor_window_start();
   -- Lihat waktu tersisa hingga periode jam sepi saat ini berakhir, dalam detik.
   SELECT * FROM polar_advisor.get_secs_to_advisor_window_end();

   Berikut adalah contohnya:

   -- Lihat detail periode jam sepi.
   postgres=# SELECT * FROM polar_advisor.get_advisor_window();
    start_time  |  end_time   | enabled | last_error_time | last_error_detail | others
   -------------+-------------+---------+-----------------+-------------------+--------
    23:00:00+08 | 02:00:00+08 | t       |                 |                   |
   (1 row)
   
   -- Lihat durasi periode jam sepi.
   postgres=# SELECT polar_advisor.get_advisor_window_length() / 3600.0 AS "window_duration_hours";
        window_duration_hours
   --------------------
    3.0000000000000000
   (1 row)
   
   -- Periksa apakah waktu saat ini berada dalam periode jam sepi.
   postgres=# SELECT now(), * FROM polar_advisor.is_in_advisor_window();
                 now              | is_in_advisor_window
   -------------------------------+----------------------
    2024-04-01 07:40:37.733911+00 | f
   (1 row)
   
   -- Lihat waktu tersisa hingga periode jam sepi berikutnya dimulai.
   postgres=# SELECT * FROM polar_advisor.get_secs_to_advisor_window_start();
    secs_to_window_start |      time_now      | window_start | window_end
   ----------------------+--------------------+--------------+-------------
            26362.265179 | 07:40:37.734821+00 | 15:00:00+00  | 18:00:00+00
   (1 row)
   
   -- Lihat waktu tersisa hingga periode jam sepi saat ini berakhir.
   postgres=# SELECT * FROM polar_advisor.get_secs_to_advisor_window_end();
    secs_to_window_end |      time_now      | window_start | window_end
   --------------------+--------------------+--------------+-------------
          36561.870337 | 07:40:38.129663+00 | 15:00:00+00  | 18:00:00+00
   (1 row)

4. Nonaktifkan atau aktifkan jendela.

   Setelah Anda menetapkan jendela, jendela tersebut diaktifkan secara default, dan pengumpulan sampah dijalankan dalam jendela ini setiap hari. Jika Anda tidak ingin kluster melakukan pengumpulan sampah selama periode jam sepi pada hari tertentu—misalnya, untuk melakukan operasi manual lain di mana Anda khawatir terjadi konflik—Anda dapat menjalankan perintah berikut untuk menonaktifkan periode jam sepi. Setelah pekerjaan selesai, Anda dapat menjalankan perintah lagi untuk mengaktifkan kembali jendela tersebut.

   -- Jalankan pada database postgres.
   
   -- Nonaktifkan pengumpulan sampah selama periode jam sepi.
   SELECT polar_advisor.disable_advisor_window();
   -- Aktifkan pengumpulan sampah selama periode jam sepi.
   SELECT polar_advisor.enable_advisor_window();
   -- Periksa apakah jendela diaktifkan.
   SELECT polar_advisor.is_advisor_window_enabled();

   Berikut adalah contohnya:

   -- Jendela diaktifkan.
   postgres=# SELECT polar_advisor.is_advisor_window_enabled();
    is_advisor_window_enabled
   ---------------------------
       t
   (1 row)
   
   -- Nonaktifkan jendela.
   postgres=# SELECT polar_advisor.disable_advisor_window();
    disable_advisor_window
   ------------------------
   
   (1 row)
   
   -- Jendela dinonaktifkan.
   postgres=# SELECT polar_advisor.is_advisor_window_enabled();
    is_advisor_window_enabled
   ---------------------------
       f
   (1 row)
   
   -- Aktifkan kembali jendela.
   postgres=# SELECT polar_advisor.enable_advisor_window();
    enable_advisor_window
   -----------------------
   
   (1 row)
   
   -- Jendela diaktifkan.
   postgres=# SELECT polar_advisor.is_advisor_window_enabled();
    is_advisor_window_enabled
   ---------------------------
       t
   (1 row)

Konfigurasi lainnya

• Tetapkan blacklist.

  Jika Anda mengonfigurasi periode jam sepi, database secara otomatis menentukan tabel mana yang akan menjalani pengumpulan sampah selama jendela tersebut. Tabel apa pun dapat dipilih. Jika Anda ingin mencegah tabel tertentu dipilih, Anda dapat menjalankan perintah berikut untuk menambahkannya ke blacklist.

  -- Jalankan di database bisnis tertentu.
  
  -- Tambahkan tabel ke blacklist VACUUM & ANALYZE.
  SELECT polar_advisor.add_relation_to_vacuum_analyze_blacklist(schema_name, relation_name);
  -- Verifikasi apakah tabel ada di blacklist VACUUM & ANALYZE.
  SELECT polar_advisor.is_relation_in_vacuum_analyze_blacklist(schema_name, relation_name);
  -- Dapatkan blacklist VACUUM & ANALYZE.
  SELECT * FROM polar_advisor.get_vacuum_analyze_blacklist();

  Berikut adalah contohnya:

  -- Tambahkan tabel public.t1 ke blacklist.
  postgres=# SELECT polar_advisor.add_relation_to_vacuum_analyze_blacklist('public', 't1');
   add_relation_to_vacuum_analyze_blacklist
  ---------------------------
      t
  (1 row)
  
  -- Periksa apakah tabel ada di blacklist.
  postgres=# SELECT polar_advisor.is_relation_in_vacuum_analyze_blacklist('public', 't1');
   is_relation_in_vacuum_analyze_blacklist
  --------------------------
      t
  (1 row)
  
  -- Dapatkan daftar lengkap blacklist untuk memastikan tabel tersebut ada di dalamnya.
  postgres=# SELECT * FROM polar_advisor.get_vacuum_analyze_blacklist();
   schema_name | relation_name |  action_type
  -------------+---------------+----------------
   public      | t1            | VACUUM ANALYZE
  (1 row)

• Tetapkan ambang batas koneksi aktif.

  Untuk mencegah pengumpulan sampah selama jam sepi memengaruhi operasi bisnis normal, sistem secara otomatis memeriksa jumlah koneksi aktif. Jika jumlah koneksi aktif melebihi ambang batas, operasi pengumpulan sampah secara otomatis dibatalkan. Anda dapat menyesuaikan ambang batas ini secara manual sesuai kebutuhan bisnis Anda. Ambang batas default berkisar antara 5 hingga 10 dan bergantung pada jumlah core CPU di kluster.

  -- Jalankan pada database postgres.
  
  -- Dapatkan ambang batas koneksi yang dapat diterima untuk periode jam sepi. Pengumpulan sampah tidak dilakukan jika jumlah aktual koneksi aktif lebih tinggi dari nilai ini.
  SELECT polar_advisor.get_active_user_conn_num_limit();
  
  -- Jalankan pernyataan SQL selama periode jam sepi untuk mendapatkan jumlah aktual koneksi aktif. Anda juga dapat melihat metrik active_session di konsol PolarDB dengan menavigasi ke Performance Monitoring > Advanced Monitoring > Standard View > Session Connection.
  SELECT COUNT(*) FROM pg_catalog.pg_stat_activity sa JOIN pg_catalog.pg_user u ON sa.usename = u.usename
  WHERE sa.state = 'active' AND sa.backend_type = 'client backend' AND NOT u.usesuper;
  
  -- Tetapkan secara manual ambang batas koneksi aktif. Ini menggantikan default sistem.
  SELECT polar_advisor.set_active_user_conn_num_limit(active_user_conn_limit);
  -- Hapus ambang batas koneksi aktif untuk mengembalikan default sistem.
  SELECT polar_advisor.unset_active_user_conn_num_limit();

  Sebagai contoh:

  -- Dapatkan ambang batas koneksi aktif default untuk instans. Ambang batas untuk instans ini adalah 5. Ambang batas dapat berbeda untuk instans berbeda berdasarkan jumlah core CPU.
  postgres=# SELECT polar_advisor.get_active_user_conn_num_limit();
  NOTICE:  get active user conn limit by CPU cores number
   get_active_user_conn_num_limit
  --------------------------------
                5
  (1 row)
  
  -- Dapatkan jumlah koneksi aktif saat ini. Hasilnya adalah 8, yang lebih besar dari ambang batas 5. Sistem menganggap jumlah koneksi aktif tinggi dan tidak akan melakukan pengumpulan sampah.
  postgres=# SELECT COUNT(*) FROM pg_catalog.pg_stat_activity sa JOIN pg_catalog.pg_user u ON sa.usename = u.usename
  postgres-# WHERE sa.state = 'active' AND sa.backend_type = 'client backend' AND NOT u.usesuper;
   count
  -------
      8
  (1 row)
  
  -- Tetapkan ambang batas koneksi aktif menjadi 10. Nilai ini lebih besar dari jumlah aktual koneksi aktif (8). Sistem menganggap jumlah koneksi aktual tidak melebihi ambang batas, sehingga pengumpulan sampah dapat dilakukan.
  postgres=# SELECT polar_advisor.set_active_user_conn_num_limit(10);
   set_active_user_conn_num_limit
  --------------------------------
  
  (1 row)
  
  -- Lihat ambang batas koneksi aktif. Nilainya adalah 10, yang ditetapkan secara manual pada langkah sebelumnya.
  postgres=# SELECT polar_advisor.get_active_user_conn_num_limit();
  NOTICE:  get active user conn limit from table
    get_active_user_conn_num_limit
  --------------------------------
              10
  (1 row)
  
  -- Hapus ambang batas koneksi aktif.
  postgres=# SELECT polar_advisor.unset_active_user_conn_num_limit();
   unset_active_user_conn_num_limit
  ----------------------------------
  
  (1 row)
  
  -- Setelah dihapus, ambang batas koneksi aktif kembali ke nilai default 5.
  postgres=# SELECT polar_advisor.get_active_user_conn_num_limit();
  NOTICE:  get active user conn limit by CPU cores number
   get_active_user_conn_num_limit
  --------------------------------
              5
  (1 row)

Skema tabel

Tabel polar_advisor.db_level_advisor_log menyimpan informasi tentang setiap putaran pengumpulan sampah tingkat database.

CREATE TABLE polar_advisor.db_level_advisor_log (
    id                      BIGSERIAL PRIMARY KEY,
    exec_id                 BIGINT,
    start_time              TIMESTAMP WITH TIME ZONE,
    end_time                TIMESTAMP WITH TIME ZONE,
    db_name                 NAME,
    event_type              VARCHAR(100),
    total_relation          BIGINT,
    acted_relation          BIGINT,
    age_before              BIGINT,
    age_after               BIGINT,
    others                  JSONB
);

Deskripsi:

Tabel polar_advisor.advisor_log menyimpan informasi rinci tentang setiap operasi pengumpulan sampah tingkat tabel atau tingkat indeks. Satu catatan di tabel polar_advisor.db_level_advisor_log berkorespondensi dengan beberapa catatan di tabel polar_advisor.advisor_log.

CREATE TABLE polar_advisor.advisor_log (
    id                      BIGSERIAL PRIMARY KEY,
    exec_id                 BIGINT,
    start_time              TIMESTAMP WITH TIME ZONE,
    end_time                TIMESTAMP WITH TIME ZONE,
    db_name                 NAME,
    schema_name             NAME,
    relation_name           NAME,
    event_type              VARCHAR(100),
    sql_cmd                 TEXT,
    detail                  TEXT,
    tuples_deleted          BIGINT,
    tuples_dead_now         BIGINT,
    tuples_now              BIGINT,
    pages_scanned           BIGINT,
    pages_pinned            BIGINT,
    pages_frozen_now        BIGINT,
    pages_truncated         BIGINT,
    pages_now               BIGINT,
    idx_tuples_deleted      BIGINT,
    idx_tuples_now          BIGINT,
    idx_pages_now           BIGINT,
    idx_pages_deleted       BIGINT,
    idx_pages_reusable      BIGINT,
    size_before             BIGINT,
    size_now                BIGINT,
    age_decreased           BIGINT,
    others                  JSONB
);

Deskripsi:

Data statistik

• Lihat waktu mulai, waktu selesai, dan jumlah tabel serta indeks yang dioperasikan untuk setiap putaran pengumpulan sampah terbaru. Berikut adalah contohnya:

  -- Jalankan pada database postgres.
  SELECT COUNT(*) AS "table_index_count", MIN(start_time) AS "start_time", MAX(end_time) AS "end_time", exec_id AS "round" FROM polar_advisor.advisor_log GROUP BY exec_id ORDER BY exec_id DESC;

  Hasil menunjukkan bahwa dalam tiga putaran terakhir, pengumpulan sampah dilakukan pada sekitar 4.390 tabel, dan operasi berjalan antara pukul 01.00 hingga 04.00.

     table_index_count |            start_time             |              end_time            | round
  -------------------+--------------------------------+--------------------------------+------
          4391 | 2024-09-23 01:00:09.413901 +08 | 2024-09-23 03:25:39.029702 +08 |  139
          4393 | 2024-09-22 01:03:07.365759 +08 | 2024-09-22 03:37:45.227067 +08 |  138
          4393 | 2024-09-21 01:03:08.094989 +08 | 2024-09-21 03:45:20.280011 +08 |  137

• Lihat jumlah tabel/indeks yang menjalani pengumpulan sampah setiap hari baru-baru ini, dikelompokkan berdasarkan tanggal. Berikut adalah contohnya:

  -- Jalankan pada database postgres.
  SELECT start_time::pg_catalog.date AS "date", count(*) AS "table_index_count" FROM polar_advisor.advisor_log GROUP BY start_time::pg_catalog.date ORDER BY start_time::pg_catalog.date DESC, count(*) DESC;

  Hasil menunjukkan bahwa pengumpulan sampah dilakukan pada sekitar 4.390 tabel setiap hari selama tiga hari terakhir.

      date     | table_index_count
  ------------+-------------------
   2024-09-23 |        4391
   2024-09-22 |        4393
   2024-09-21 |        4393

• Lihat jumlah tabel/indeks yang baru-baru ini menjalani pengumpulan sampah, dikelompokkan berdasarkan tanggal dan database. Berikut adalah contohnya:

  -- Jalankan di database postgres
  SELECT start_time::pg_catalog.date AS "Time", count(*) AS "Table/Index Count" FROM polar_advisor.advisor_log GROUP BY start_time::pg_catalog.date ORDER BY start_time::pg_catalog.date DESC, count(*) DESC;

  Hasil menunjukkan bahwa pengumpulan sampah dilakukan pada database postgres, db_123, db_12345, dan db_123456789 selama tiga hari terakhir. Jumlah tabel/indeks yang dioperasikan per database berkisar dari puluhan hingga ratusan.

        date    |       db       | table_index_count
  -------------+----------------+-------------------
    2024-03-05 | db_123456789   |     697
    2024-03-05 | db_123         |     277
    2024-03-04 | db_123456789   |     695
    2024-03-04 | db_123         |     267
    2024-03-04 | db_12345       |     174
    2024-03-03 | postgres       |      65
  (6 rows)

Data rinci

• Lihat informasi manfaat untuk database yang baru-baru ini menjalani pengumpulan sampah. Berikut adalah contohnya:

  -- Jalankan pada database postgres.
  SELECT id, start_time AS "start_time", end_time AS "end_time", db_name AS "database", event_type AS "operation_type", total_relation AS "total_relations_in_db", acted_relation AS "operated_relations",
      CASE WHEN others->>'cluster_age_before' IS NOT NULL AND others->>'cluster_age_after' IS NOT NULL THEN (others->>'cluster_age_before')::BIGINT - (others->>'cluster_age_after')::BIGINT ELSE NULL END AS "age_reduction",
      CASE WHEN others->>'db_size_before' IS NOT NULL AND others->>'db_size_after' IS NOT NULL THEN (others->>'db_size_before')::BIGINT - (others->>'db_size_after')::BIGINT ELSE NULL END AS "storage_reduction"
  FROM polar_advisor.db_level_advisor_log ORDER BY id DESC;

  Hasil menunjukkan bahwa tiga operasi terakhir semuanya merupakan operasi VACUUM.

      id   |            start_time            |             end_time            |      database     | operation_type  |  total_relations_in_db  |  operated_relations  |  age_reduction  | storage_reduction
  ---------+-------------------------------+-------------------------------+----------------+----------+----------------+--------------+----------+--------------
      1184 | 2024-03-05 00:44:26.776894+08 | 2024-03-05 00:45:56.396519+08 | db_12345       | VACUUM   |            174 |          164 |      694 |            0
      1183 | 2024-03-05 00:43:30.243505+08 | 2024-03-05 00:44:26.695602+08 | db_123456789   | VACUUM   |            100 |           90 |      396 |            0
      1182 | 2024-03-05 00:41:47.70952+08  | 2024-03-05 00:43:30.172527+08 | db_12345       | VACUUM   |            163 |          153 |      701 |            0
  (3 rows)

• Lihat informasi manfaat untuk tabel yang baru-baru ini menjalani pengumpulan sampah. Berikut adalah contohnya:

  -- Jalankan pada database postgres.
  SELECT start_time AS "start_time", end_time AS "end_time", db_name AS "database", schema_name AS "schema", relation_name AS "table_index", event_type AS "operation_type", tuples_deleted AS "reclaimed_dead_tuples", pages_scanned AS "pages_scanned",pages_truncated AS "pages_truncated", idx_tuples_deleted AS "reclaimed_index_dead_tuples", idx_pages_deleted AS "reclaimed_index_pages", age_decreased AS "table_age_reduction" FROM polar_advisor.advisor_log ORDER BY id DESC;

  Hasil menunjukkan informasi seperti jumlah dead tuple yang dipulihkan, halaman yang dipulihkan, dan pengurangan usia tabel untuk tiga operasi terakhir.

               start_time           |             end_time            |   database  |  schema  |  table_index | operation_type | reclaimed_dead_tuples | pages_scanned | pages_truncated | reclaimed_index_dead_tuples | reclaimed_index_pages | table_age_reduction
  -------------------------------+-------------------------------+----------+--------+--------+---------+------------+---------+---------+---------------+------------+------------
   2024-03-05 00:45:56.204254+08 | 2024-03-05 00:45:56.357263+08 | db_12345 | public |  cccc  | VACUUM  |        0   |      33 |      0  |             0 |         0  |    1345944
   2024-03-05 00:45:56.068499+08 | 2024-03-05 00:45:56.200036+08 | db_12345 | public |  aaaa  | VACUUM  |        0   |      28 |      0  |             0 |         0  |    1345946
   2024-03-05 00:45:55.945677+08 | 2024-03-05 00:45:56.065316+08 | db_12345 | public |  bbbb  | VACUUM  |        0   |       0 |      0  |             0 |         0  |    1345947
  (3 rows)

• Lihat catatan operasi dengan pengurangan usia database terbesar.

  PolarDB for PostgreSQL dan memiliki sekitar 2,1 miliar transaction ID yang tersedia. Usia database mengukur jumlah transaction ID yang dikonsumsi. Ketika usia mencapai 2,1 miliar, terjadi event transaction ID wraparound dan database menjadi tidak tersedia. Oleh karena itu, usia database yang lebih rendah lebih baik.

  -- Jalankan pada database postgres.
  
  -- Dapatkan catatan untuk database dan jenis operasi dengan pengurangan usia instans terbesar.
  SELECT id, exec_id AS "round", start_time AS "start_time", end_time AS "end_time", db_name AS "database", event_type AS "operation_type", CASE WHEN others->>'cluster_age_before' IS NOT NULL AND others->>'cluster_age_after' IS NOT NULL THEN (others->>'cluster_age_before')::BIGINT - (others->>'cluster_age_after')::BIGINT ELSE NULL END AS "age_reduction" FROM polar_advisor.db_level_advisor_log ORDER BY "age_reduction" DESC NULLS LAST;
  
  -- Berdasarkan informasi putaran dari langkah sebelumnya, dapatkan catatan rinci yang menyebabkan pengurangan usia database dalam putaran tersebut.
  SELECT id, start_time AS "start_time", end_time AS "end_time", db_name AS "database", schema_name AS "schema", relation_name AS "table_name", sql_cmd AS "command", event_type AS "operation_type", age_decreased AS "age_reduction" FROM polar_advisor.advisor_log WHERE exec_id = 91 ORDER BY "age_reduction" DESC NULLS LAST;
  
  -- Dapatkan usia database saat ini. Ini dapat dijalankan di database apa pun. Anda juga dapat melihat metrik db_age di konsol PolarDB dengan menavigasi ke Performance Monitoring > Advanced Monitoring > Standard View > Vacuum.
  SELECT MAX(pg_catalog.age(datfrozenxid)) AS "instance_age" FROM pg_catalog.pg_database;

  Berikut adalah contoh hasilnya:

  -- Pada 2024-02-22, operasi vacuum pada database 'aaaaaaaaaaaaa' mengurangi usia database sebesar 9.275.406 (hampir 10 juta). Putaran eksekusi adalah 91.
  postgres=# SELECT id, exec_id AS "round", start_time AS "start_time", end_time AS "end_time", db_name AS "database", event_type AS "operation_type", CASE WHEN others->>'cluster_age_before' IS NOT NULL AND others->>'cluster_age_after' IS NOT NULL THEN (others->>'cluster_age_before')::BIGINT - (others->>'cluster_age_after')::BIGINT ELSE NULL END AS "age_reduction" FROM polar_advisor.db_level_advisor_log ORDER BY "age_reduction" DESC NULLS LAST;
  id      | round  |           start_time             |           end_time             |    database      | operation_type   | age_reduction
  --------+------+-------------------------------+-------------------------------+---------------+----------+----------
      259 |   91 | 2024-02-22 00:00:18.847978+08 | 2024-02-22 00:14:18.785085+08 | aaaaaaaaaaaaa | VACUUM   |  9275406
      256 |   90 | 2024-02-21 00:00:39.607552+08 | 2024-02-21 00:00:42.054733+08 | bbbbbbbbbbbbb | VACUUM   |  7905122
      262 |   92 | 2024-02-23 00:00:05.999423+08 | 2024-02-23 00:00:08.411993+08 | postgres      | VACUUM   |   578308
  
  -- Dapatkan catatan vacuum rinci untuk putaran eksekusi 91. Hasil menunjukkan bahwa pengurangan usia database terutama disebabkan oleh operasi vacuum pada beberapa tabel sistem pg_catalog.
  postgres=# SELECT id, start_time AS "start_time", end_time AS "end_time", db_name AS "database", schema_name AS "schema", relation_name AS "table_name", event_type AS "operation_type", age_decreased AS "age_reduction" FROM polar_advisor.advisor_log WHERE exec_id = 91 ORDER BY "age_reduction" DESC NULLS LAST;
      id    |           start_time             |           end_time              | database |    schema    |        table_name         | operation_type | age_reduction
  ----------+-------------------------------+-------------------------------+-------+------------+--------------------+---------+----------
      43933 | 2024-02-22 00:00:19.070493+08 | 2024-02-22 00:00:19.090822+08 |  abc  | pg_catalog | pg_subscription    | VACUUM  | 27787409
      43935 | 2024-02-22 00:00:19.116292+08 | 2024-02-22 00:00:19.13875+08  |  abc  | pg_catalog | pg_database        | VACUUM  | 27787408
      43936 | 2024-02-22 00:00:19.140992+08 | 2024-02-22 00:00:19.171938+08 |  abc  | pg_catalog | pg_db_role_setting | VACUUM  | 27787408
  
  -- Usia instans saat ini lebih dari 20 juta, yang masih jauh dari ambang batas 2,1 miliar. Instans sangat aman.
  postgres=> SELECT MAX(pg_catalog.age(datfrozenxid)) AS "instance_age" FROM pg_catalog.pg_database;
   instance_age
  ----------
   20874380
  (1 row)

Efek optimasi penggunaan memori

Seperti ditunjukkan pada gambar berikut, setelah mengonfigurasi pengumpulan sampah untuk periode jam sepi, penggunaan memori puncak proses autovacuum kluster turun dari 2,06 GB menjadi 37 MB, penurunan sebesar 98%.

Total penggunaan memori puncak semua proses juga turun dari 10 GB menjadi 8 GB, penurunan sebesar 20%.

Efek optimasi penggunaan I/O

Seperti ditunjukkan pada gambar berikut, setelah periode jam sepi dikonfigurasi, PFS IOPS puncak proses autovacuum kluster berkurang sekitar 50%.

Total PFS IOPS puncak semua proses juga turun dari 35.000 menjadi sekitar 21.000, penurunan sekitar 40%.

Throughput I/O PFS puncak proses autovacuum turun dari 225 MB menjadi 173 MB, penurunan 23%. Lebar dan jumlah puncak juga berkurang secara signifikan. Throughput rata-rata turun dari 65,5 MB menjadi 42,5 MB, penurunan 35%.

Efek optimasi penggunaan CPU

Seperti ditunjukkan pada gambar berikut, setelah periode jam sepi dikonfigurasi, utilisasi CPU proses autovacuum kluster berangsur-angsur menurun, dengan pengurangan puncak sekitar 50%.

Efek optimasi jumlah proses autovacuum

Seperti ditunjukkan pada gambar berikut, setelah periode jam sepi dikonfigurasi, jumlah proses autovacuum di kluster berkurang dari 2 menjadi 1.

Efek optimasi usia database

Seperti ditunjukkan pada gambar berikut, dalam dua hari setelah mengonfigurasi periode jam sepi, kluster memulihkan lebih dari 1 miliar transaction ID. Usia database turun dari lebih dari 1 miliar menjadi kurang dari 100 juta, secara signifikan mengurangi risiko transaction ID wraparound.