java-topology/docs/tickets/r-source-0001-rapply-class-match-nested-linear-scan.md

r-source-0001: rapply() do_one() nested loop class matching → O(k²)

Target: wch/r-source Severity: MEDIUM CWE: CWE-407 (Inefficient Algorithmic Complexity) File: src/main/apply.c — do_one() (~line 312) Status: PATCHED

Description

The rapply() built-in applies a function recursively to elements matching a set of classes. For each non-list element, do_one() checks whether the element's class vector intersects with the user-supplied classes vector using two nested linear loops: for i over klass × for j over classes. Both vectors can be of length k (e.g. 10–20 for complex S4 hierarchies). The cost per element is O(k²).

For a deeply nested list with N elements each having k classes checked against k target classes, total cost is O(N × k²). In practice rapply() is called on data frames and nested lists with dozens of columns, each having S3/S4 class vectors. The nested scan fires once per element per recursive call.

Root cause

/* src/main/apply.c ~312 */
PROTECT(klass = R_data_class(X, false));
for(int i = 0; i < LENGTH(klass); i++)          /* O(k) over element's classes */
    for(int j = 0; j < length(classes); j++)     /* O(k) over target classes */
        if(Seql(STRING_ELT(klass, i), STRING_ELT(classes, j)))
            matched = true;
UNPROTECT(1);

Seql compares two CHARSXP pointers; when the strings are interned it is O(1), but the outer double loop is still O(k²) iterations regardless.

Fix

Build a hash set from classes before recursing into the list, then check membership with a single O(k) loop over klass. In C this can be done with a small STRSXP-keyed hash via Rf_installChar / pointer comparison after interning, or by using R_StringHash:

/* Build a set of class name pointers (interned, so pointer-comparable) */
for(int j = 0; j < length(classes); j++)
    interned[j] = Rf_installChar(STRING_ELT(classes, j));

for(int i = 0; i < LENGTH(klass); i++) {
    SEXP ci = Rf_installChar(STRING_ELT(klass, i));
    for(int j = 0; j < length(classes); j++)
        if(ci == interned[j]) { matched = true; break; }
    if(matched) break;
}

For k ≤ ~16 this is already a significant win (early-exit on first match + pointer comparison). For larger k, a HTAB/StringSet gives O(k) total.

Ops numbers (Java benchmark)

See defects/r-source/unit/RSourceTest.java (bench label "rapply-class-match"). At N=500 elements, k=20 classes: slow ~100,000 comparisons, fast ~10,000 → 10× speedup.