R Academy · Pelajaran

system.time() dan proc.time()

Ukur waktu berlalu, waktu pengguna, dan waktu sistem untuk ekspresi R.

system.time() dan proc.time() adalah pelajaran R Academy gratis di CoddyKit. Ini adalah pelajaran 1 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar R Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus R Academy mencakup 4 pelajaran total.

Mengapa Mengukur Kinerja?

Sebelum mengoptimalkan kode, Anda perlu mengukurnya. Menebak di mana kelambatan terjadi hanya membuang usaha. R menyediakan alat bawaan untuk mengukur durasi expression secara presisi.

Tiga alat utama adalah system.time(), proc.time(), dan Sys.time(). Masing-masing memiliki tujuan berbeda dalam analisis kinerja.

Dasar-Dasar system.time()

system.time(expr) mengevaluasi expression dan mengembalikan durasi yang dibutuhkan. Ini adalah cara paling sederhana untuk mengukur satu operasi di R.

Hasilnya adalah objek dari class proc_time dengan elemen bernama yang dapat Anda periksa.

result <- system.time({
  x <- 1:1000000
  total <- sum(x)
})
print(result)

Membaca Tiga Nilai time

system.time() mengembalikan lima nilai, tetapi tiga yang paling penting adalah:

user — CPU time yang digunakan oleh kode R itu sendiri
sys — CPU time yang digunakan oleh OS atas nama R
elapsed — wall-clock time (detik nyata yang telah berlalu)

Biasanya, elapsed adalah nilai yang paling Anda perlukan. User + sys dapat melebihi elapsed pada mesin dengan banyak inti.

t <- system.time(Sys.sleep(0.1))
cat('user   :', t['user.self'], '
')
cat('sys    :', t['sys.self'], '
')
cat('elapsed:', t['elapsed'], '
')

proc.time() untuk Pengukuran Manual

proc.time() mengembalikan CPU time dan elapsed time saat ini sebagai snapshot. Dengan mengambilnya sebelum dan sesudah suatu blok, Anda dapat mengukur bagian kode apa pun.

Kurangkan snapshot awal dari snapshot akhir untuk mendapatkan elapsed time bagian tersebut.

start <- proc.time()
for (i in 1:100000) sqrt(i)
end <- proc.time()
diff <- end - start
cat('elapsed:', diff['elapsed'], 'seconds
')

Komponen proc.time()

proc.time() mengembalikan vektor numeric bernama dengan tiga elemen:

user.self — user CPU time untuk proses R
sys.self — system CPU time untuk proses R
elapsed — wall-clock time sejak R dimulai

Selisih antara dua pemanggilan proc.time() memberikan delta pengukuran yang bermakna.

pt <- proc.time()
cat('Names:', names(pt), '
')
cat('Values:', pt, '
')
cat('Class:', class(pt), '
')

Sys.time() untuk Stempel Wall Clock

Sys.time() mengembalikan tanggal dan waktu saat ini sebagai objek POSIXct. Berbeda dari proc.time(), fungsi ini memberikan stempel waktu dunia nyata, bukan sekadar penggunaan CPU.

Ini berguna untuk mencatat kapan sesuatu terjadi, bukan hanya berapa lama durasinya.

start_time <- Sys.time()
cat('Start:', format(start_time), '
')
Sys.sleep(0.05)
end_time <- Sys.time()
cat('End  :', format(end_time), '
')

difftime() untuk Mengukur Interval

difftime(end, start, units='secs') menghitung selisih antara dua stempel waktu POSIXct. Anda dapat memilih satuan: 'secs', 'mins', 'hours', 'days'.

Fungsi ini cocok digunakan bersama Sys.time() untuk menghasilkan output pengukuran yang mudah dibaca.

t1 <- Sys.time()
x <- cumsum(1:500000)
t2 <- Sys.time()
delta <- difftime(t2, t1, units = 'secs')
cat('Time taken:', round(as.numeric(delta), 4), 'seconds
')

Pengukuran dalam Perulangan dengan replicate()

Satu pengukuran dapat berbeda-beda karena garbage collection atau penjadwalan OS. replicate(n, system.time(expr)['elapsed']) menjalankan expression beberapa kali dan mengembalikan vektor berisi elapsed time.

Mengambil median dari pengukuran berulang memberikan perkiraan yang lebih stabil.

times <- replicate(10, system.time({
  x <- rnorm(10000)
  mean(x)
})['elapsed'])
cat('Median elapsed:', median(times), 'seconds
')
cat('Range:', range(times), '
')

Membandingkan Dua Pendekatan

Gunakan system.time() untuk membandingkan langsung dua implementasi tugas yang sama. Pola ini membantu Anda memastikan bahwa salah satu pendekatan memang lebih cepat sebelum menggunakannya.

n <- 100000
t_loop <- system.time({
  result <- numeric(n)
  for (i in seq_len(n)) result[i] <- i^2
})['elapsed']

t_vec <- system.time({
  result <- seq_len(n)^2
})['elapsed']

cat('Loop   :', t_loop, 's
')
cat('Vector :', t_vec, 's
')
cat('Speedup:', round(t_loop / max(t_vec, 1e-6), 1), 'x
')

Mengukur Operasi Bertingkat

Anda dapat menumpuk pemanggilan system.time() atau menggunakan checkpoint proc.time() di dalam alur kerja untuk menemukan langkah yang menjadi hambatan.

Cetak delta perantara saat skrip berjalan untuk membangun linimasa pipeline Anda.

p0 <- proc.time()
x <- rnorm(200000)
p1 <- proc.time()
y <- sort(x)
p2 <- proc.time()
z <- cumsum(y)
p3 <- proc.time()

cat('Generate:', (p1-p0)['elapsed'], 's
')
cat('Sort    :', (p2-p1)['elapsed'], 's
')
cat('Cumsum  :', (p3-p2)['elapsed'], 's
')

Kiat Praktis untuk Pengukuran

Ingat praktik berikut saat mengukur kode R:

Jalankan kode sekali sebelum pengukuran untuk memanaskan JIT dan cache file
Gunakan gc() sebelum pengukuran untuk mengatur ulang status garbage collection
Utamakan median daripada mean pada pengulangan — pencilan dari GC dapat mengubah mean
Ukur hambatan utama, bukan seluruh skrip

gc()  # clear garbage before timing
times <- replicate(5, system.time({
  m <- matrix(rnorm(1000 * 1000), nrow = 1000)
  crossprod(m)
})['elapsed'])
cat('Median:', median(times), 's
')

Pemeriksaan Singkat: Komponen system.time()

Komponen system.time() manakah yang menunjukkan detik wall-clock sebenarnya yang berlalu selama eksekusi?

Rangkuman Pengukuran Kinerja

Sekarang Anda memiliki tiga alat pengukuran yang saling melengkapi dalam R dasar:

system.time(expr) — cara tercepat untuk mengukur satu expression; mengembalikan user/sys/elapsed
proc.time() — pengukuran berbasis snapshot untuk blok kode apa pun
Sys.time() + difftime() — stempel wall-clock dan interval yang mudah dibaca

Gunakan replicate() untuk memperoleh pengukuran median yang stabil sebelum menarik kesimpulan tentang kinerja.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “system.time() dan proc.time()” gratis?

Ya — teks lengkap “system.time() dan proc.time()” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus R Academy, upgrade ke CoddyKit PRO. Kursus R Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “system.time() dan proc.time()”?

Ukur waktu berlalu, waktu pengguna, dan waktu sistem untuk ekspresi R. Kamu berlatih R Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai R Academy?

Tidak diperlukan pengalaman sebelumnya. R Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 1 dari 4.

Berapa lama pelajaran “system.time() dan proc.time()” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran R Academy ini?

Ya. Setiap pelajaran R Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

system.time() dan proc.time()
Membuat Profil Kode dengan Rprof dan profvis
Vektorisasi untuk Kecepatan
Menguji Kinerja dengan microbenchmark

← Kembali ke R Academy