object.size {utils} | R Documentation

## Report the Space Allocated for an Object

### Description

Provides an estimate of the memory that is being used to store an R object.

### Usage

    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, ...)

### Arguments

`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 `standard`s are `standard = "legacy"`: `"b"`, `"Kb"`, `"Mb"`, `"Gb"`, `"Tb"`, `"Pb"`, `"B"`, `"KB"`, `"MB"`, `"GB"`, `"TB"` and `"PB"`. `standard = "IEC"`: `"B"`, `"KiB"`, `"MiB"`, `"GiB"`, `"TiB"`, `"PiB"`, `"EiB"`, `"ZiB"` and `"YiB"`. `standard = "SI"`: `"B"`, `"kB"`, `"MB"`, `"GB"`, `"TB"`, `"PB"`, `"EB"`, `"ZB"` and `"YB"`. For all standards, `unit = "auto"` is also allowed. If `standard = "auto"`, any of the "legacy" and IEC units are allowed. See ‘Formatting and printing object sizes’ for details.
`standard` | the byte-size unit standard to be used. A character string, possibly abbreviated from `"legacy"`, `"IEC"`, `"SI"` and `"auto"`. See ‘Formatting and printing object sizes’ for details.
`digits` | the number of digits after the decimal point, passed to `round`.
`...` | arguments to be passed to or from other methods.

### Details

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.

### Value

An object of class `"object_size"` with a length-one double value, an estimate of the memory allocation attributable to the object in bytes.

### Formatting and printing object sizes

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

### Author(s)

R Core; Henrik Bengtsson for the non-legacy `standard`s.

### References

The wikipedia page, https://en.wikipedia.org/wiki/Binary_prefix, is extensive on the different standards, usages and their history.

### See Also

`Memory-limits` for the design limitations on object size.

### Examples

    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])

[Package utils version 3.5.1 Index]