| object.size {utils} | R Documentation |
Provides an estimate of the memory that is being used to store an R object.
object.size(x)
## S3 method for class 'object_size'
format(x, units = "b", standard = "auto", digits = 1L, ...)
## S3 method for class 'object_size'
print(x, quote = FALSE, units = "b", standard = "auto",
digits = 1L, ...)
x |
an R object. |
quote |
logical, indicating whether or not the result should be printed with surrounding quotes. |
units |
the units to be used in formatting and printing the size.
Allowed values for the different
For all standards, |
standard |
the byte-size unit standard to be used. A character
string, possibly abbreviated from |
digits |
the number of digits after the decimal point, passed to
|
... |
arguments to be passed to or from other methods. |
Exactly which parts of the memory allocation should be attributed to which object is not clear-cut. This function merely provides a rough indication: it should be reasonably accurate for atomic vectors, but does not detect if elements of a list are shared, for example. (Sharing amongst elements of a character vector is taken into account, but not that between character vectors in a single object.)
The calculation is of the size of the object, and excludes the space needed to store its name in the symbol table.
Associated space (e.g., the environment of a function and what the
pointer in a EXTPTRSXP points to) is not included in the
calculation.
Object sizes are larger on 64-bit builds than 32-bit ones, but will very likely be the same on different platforms with the same word length and pointer size.
Sizes of objects using a compact internal representation may be over-estimated.
An object of class "object_size" with a length-one double value,
an estimate of the memory allocation attributable to the object in bytes.
Object sizes can be formatted using byte-size units from R's legacy standard, the IEC standard, or the SI standard. As illustrated by below tables, the legacy and IEC standards use binary units (multiples of 1024), whereas the SI standard uses decimal units (multiples of 1000).
For methods format and print, argument standard
specifies which standard to use and argument units specifies
which byte-size unit to use. units = "auto" chooses the largest
units in which the result is one or more (before rounding).
Byte sizes are rounded to digits decimal places.
standard = "auto" chooses the standard based on units,
if possible, otherwise, the legacy standard is used.
Summary of R's legacy and IEC units:
| object size | legacy | IEC |
| 1 | 1 bytes | 1 B |
| 1024 | 1 Kb | 1 KiB |
| 1024^2 | 1 Mb | 1 MiB |
| 1024^3 | 1 Gb | 1 GiB |
| 1024^4 | 1 Tb | 1 TiB |
| 1024^5 | 1 Pb | 1 PiB |
| 1024^6 | 1 EiB | |
| 1024^7 | 1 ZiB | |
| 1024^8 | 1 YiB | |
Summary of SI units:
| object size | SI |
| 1 | 1 B |
| 1000 | 1 kB |
| 1000^2 | 1 MB |
| 1000^3 | 1 GB |
| 1000^4 | 1 TB |
| 1000^5 | 1 PB |
| 1000^6 | 1 EB |
| 1000^7 | 1 ZB |
| 1000^8 | 1 YB |
R Core; Henrik Bengtsson for the non-legacy standards.
The wikipedia page, https://en.wikipedia.org/wiki/Binary_prefix, is extensive on the different standards, usages and their history.
Memory-limits for the design limitations on object size.
object.size(letters)
object.size(ls)
format(object.size(library), units = "auto")
sl <- object.size(rep(letters, 1000))
print(sl) ## 209288 bytes
print(sl, units = "auto") ## 204.4 Kb
print(sl, units = "auto", standard = "IEC") ## 204.4 KiB
print(sl, units = "auto", standard = "SI") ## 209.3 kB
(fsl <- sapply(c("Kb", "KB", "KiB"),
function(u) format(sl, units = u)))
stopifnot(identical( ## assert that all three are the same :
unique(substr(as.vector(fsl), 1,5)),
format(round(as.vector(sl)/1024, 1))))
## find the 10 largest objects in the base package
z <- sapply(ls("package:base"), function(x)
object.size(get(x, envir = baseenv())))
if(interactive()) {
as.matrix(rev(sort(z))[1:10])
} else # (more constant over time):
names(rev(sort(z))[1:10])