Improving string vector performance for push_back and subscript assignment

[traversc]

When performing subscript assignment of a std::string to writable::strings there's first a conversion to the r_string class which includes a protection. However, that protection shouldn't be necessary if the result is immediately assigned and there is no translation.

Here's a benchmark compared to Rcpp, where I am generating random strings and assigning them to a pre-allocated vector.

microbenchmark(
 rcpp = assign_rcpp(n=1e5, -1), # Assign random strings to Rcpp::CharacterVector
 cpp11 = assign_cpp11(n=1e5, -1), # Assign random strings to cpp11::writable::strings
 times = 20, setup = gc(full=TRUE))

Unit: milliseconds
 expr min lq mean median uq max neval
 rcpp 35.09063 36.53801 37.74236 37.3688 39.03084 41.29021 20
 cpp11 145.24590 148.24958 154.64878 151.7362 158.87924 177.13784 20

(The performance difference depends a lot on platform, but there's a 4x difference on a mac laptop.)

One possibility is to add some sort of overload or specialization for std::string for subscript assignment and push_back to short circuit the conversion to r_string.

Here's an example for push_back (https://github.com/traversc/cpp11/blob/main/inst/include/cpp11/strings.hpp#L133)

microbenchmark::microbenchmark(
 grow_strings_cpp11 = grow_strings_cpp11(1e5, -1), # push_back 1e5 random strings, existing implementation
 grow_strings_fast_cpp11 = grow_strings_fast_cpp11(1e5, -1), # push_back_fast implementation
 grow_strings_manual = grow_strings_manual(1e5, -1), # manual re-implementation using only SEXP
 times = 20, setup = gc(full=TRUE))

Unit: milliseconds
 expr min lq mean median uq max neval
 grow_strings_cpp11 148.06594 152.42953 158.78716 156.06482 163.46553 183.88168 20
 grow_strings_fast_cpp11 38.22086 39.39721 40.47245 40.07249 41.43170 44.69328 20
 grow_strings_manual 38.65436 40.02137 41.00465 41.10390 41.81826 46.18455 20

assign_rcpp / assign_cpp11 benchmark functions

#include <random>
std::random_device rd;
std::mt19937 gen(rd());

int random_int(int min, int max) {
 std::uniform_int_distribution<int> dist(min, max);
 return dist(gen);
}

std::string random_string() {
 std::string s(10, '\0');
 for (size_t i = 0; i < 10; i++) {
 s[i] = random_int(0, 25) + 'a';
 }
 return s;
}

#include <Rcpp.h>
using namespace Rcpp;

# Rcpp
// [[Rcpp::export(rng=false)]]
CharacterVector assign_rcpp(size_t n, int seed) {
 CharacterVector x(n);
 if(seed != -1) gen.seed(seed);
 for (size_t i = 0; i < n; ++i) {
 x[i] = random_string();
 }
 return x;
}

#include "cpp11.hpp"
using namespace cpp11;
namespace writable = cpp11::writable;

# cpp11
[[cpp11::register]]
writable::strings assign_cpp11(size_t n, int seed) {
 if(seed != -1) gen.seed(seed);
 writable::strings x(n);
 for (size_t i = 0; i < n; ++i) {
 x[i] = random_string();
 }
 return x;
}

push_back benchmark functions

#include "cpp11.hpp"
#include <vector>
#include <random>
using namespace cpp11;
namespace writable = cpp11::writable;

std::random_device rd;
std::mt19937 gen(rd());

double random_double() {
 std::uniform_real_distribution<double> dist(0.0, 1.0);
 return dist(gen);
}

int random_int(int min, int max) {
 std::uniform_int_distribution<int> dist(min, max);
 return dist(gen);
}

std::string random_string() {
 std::string s(10, '\0');
 for (size_t i = 0; i < 10; i++) {
 s[i] = random_int(0, 25) + 'a';
 }
 return s;
}

[[cpp11::register]]
writable::strings grow_strings_cpp11(size_t n, int seed) {
 if(seed != -1) gen.seed(seed);
 writable::strings x;
 for (size_t i = 0; i < n; ++i) {
 x.push_back(random_string());
 }
 return x;
}

[[cpp11::register]]
writable::strings grow_strings_fast_cpp11(size_t n, int seed) {
 if(seed != -1) gen.seed(seed);
 writable::strings x;
 for (size_t i = 0; i < n; ++i) {
 x.push_back_fast(random_string());
 }
 return x;
}

[[cpp11::register]]
SEXP grow_strings_manual(size_t n, int seed) {
 if(seed != -1) gen.seed(seed);
 SEXP data_ = PROTECT(Rf_allocVector(STRSXP, 0));
 size_t size_ = 0;
 size_t capacity_ = 0;
 for (size_t i = 0; i < n; ++i) {
 if(size_ == capacity_) {
 capacity_ = capacity_ == 0 ? 1 : capacity_ * 2;
 SEXP new_data_ = PROTECT(Rf_allocVector(STRSXP, capacity_));
 for(size_t j = 0; j < size_; ++j) {
 SET_STRING_ELT(new_data_, j, STRING_ELT(data_, j));
 }
 UNPROTECT(2);
 data_ = PROTECT(new_data_);
 }
 SET_STRING_ELT(data_, size_++, Rf_mkChar(random_string().c_str()));
 }
 // copy back down to size
 if(size_ < capacity_) {
 SEXP new_data_ = PROTECT(Rf_allocVector(STRSXP, size_));
 for(size_t j = 0; j < size_; ++j) {
 SET_STRING_ELT(new_data_, j, STRING_ELT(data_, j));
 }
 UNPROTECT(2);
 return new_data_;
 } else {
 UNPROTECT(1);
 return data_;
 }
}