High-Performance JSON Parsing in Rust: Memory-Efficient Techniques and Optimizations

Memory-efficient JSON parsing in Rust requires careful consideration of allocation patterns and performance optimizations. I’ve spent considerable time implementing these techniques in production systems, and I’ll share the most effective approaches I’ve discovered.

Borrow-based parsing forms the foundation of memory-efficient JSON processing. Instead of allocating new strings for every value, we can use references to the original input buffer:

struct BorrowedParser<'a> {
    input: &'a [u8],
    position: usize,
}

impl<'a> BorrowedParser<'a> {
    fn parse_string(&mut self) -> Result<&'a str> {
        let start = self.position + 1;
        while self.position < self.input.len() {
            if self.input[self.position] == b'"' {
                return std::str::from_utf8(&self.input[start..self.position]).map_err(|_| ParseError);
            }
            self.position += 1;
        }
        Err(ParseError)
    }
}

SIMD operations can significantly accelerate parsing by processing multiple bytes simultaneously. Modern CPUs support vector instructions that we can leverage:

use std::arch::x86_64::{__m256i, _mm256_cmpeq_epi8, _mm256_loadu_si256, _mm256_movemask_epi8};

fn find_quotes(input: &[u8]) -> u32 {
    let quote_vec = _mm256_set1_epi8(b'"' as i8);
    let data_vec = unsafe { _mm256_loadu_si256(input.as_ptr() as *const __m256i) };
    let mask = unsafe { _mm256_cmpeq_epi8(data_vec, quote_vec) };
    unsafe { _mm256_movemask_epi8(mask) as u32 }
}

Streaming parsing enables processing of large JSON documents without loading them entirely into memory. I’ve implemented this pattern successfully in several projects:

struct StreamParser {
    buffer: Vec<u8>,
    offset: usize,
}

impl StreamParser {
    fn process_chunk(&mut self, chunk: &[u8]) -> Vec<Event> {
        let mut events = Vec::new();
        self.buffer.extend_from_slice(chunk);
        
        while let Some(event) = self.parse_next() {
            events.push(event);
            self.compact_buffer();
        }
        events
    }

    fn compact_buffer(&mut self) {
        if self.offset > self.buffer.len() / 2 {
            self.buffer.drain(..self.offset);
            self.offset = 0;
        }
    }
}

Memory pools reduce allocation overhead by reusing objects. This technique works particularly well for parsing arrays and objects:

struct JsonPool {
    strings: Vec<String>,
    arrays: Vec<Vec<Value>>,
    index: usize,
}

impl JsonPool {
    fn get_string(&mut self) -> &mut String {
        if self.index >= self.strings.len() {
            self.strings.push(String::with_capacity(32));
        }
        let string = &mut self.strings[self.index];
        string.clear();
        self.index += 1;
        string
    }

    fn reset(&mut self) {
        self.index = 0;
    }
}

Direct number parsing avoids intermediate string allocations and improves performance:

fn parse_number(input: &[u8]) -> Result<f64> {
    let mut integer: i64 = 0;
    let mut position = 0;
    let mut negative = false;

    if input[0] == b'-' {
        negative = true;
        position += 1;
    }

    while position < input.len() && input[position].is_ascii_digit() {
        integer = integer * 10 + (input[position] - b'0') as i64;
        position += 1;
    }

    let result = if negative { -integer as f64 } else { integer as f64 };
    Ok(result)
}

These techniques can be combined to create a highly efficient JSON parser. The key is to minimize allocations and maximize throughput:

struct EfficientParser<'a> {
    borrowed_parser: BorrowedParser<'a>,
    pool: JsonPool,
    simd_enabled: bool,
}

impl<'a> EfficientParser<'a> {
    fn parse_value(&mut self) -> Result<Value> {
        match self.borrowed_parser.peek_byte()? {
            b'"' => self.parse_string(),
            b'[' => self.parse_array(),
            b'{' => self.parse_object(),
            b'0'..=b'9' | b'-' => self.parse_number(),
            _ => Err(ParseError),
        }
    }
}

Real-world JSON parsing often requires handling malformed input and providing meaningful error messages. I recommend implementing robust error handling:

#[derive(Debug)]
struct ParseError {
    kind: ErrorKind,
    position: usize,
    context: String,
}

impl ParseError {
    fn new(kind: ErrorKind, position: usize, context: &str) -> Self {
        Self {
            kind,
            position,
            context: context.to_string(),
        }
    }
}

The performance impact of these optimizations can be significant. In my experience, combining these techniques can lead to parsing speeds that are several times faster than naive implementations:

fn benchmark_parser() {
    let input = include_bytes!("large.json");
    let mut parser = EfficientParser::new(input);
    
    let start = std::time::Instant::now();
    let result = parser.parse().unwrap();
    let duration = start.elapsed();
    
    println!("Parsed {} bytes in {:?}", input.len(), duration);
}

When implementing these techniques, it’s essential to profile your specific use case. Different JSON structures and input sizes may benefit from different optimization strategies.

Error handling deserves special attention. A production-ready parser should handle all edge cases gracefully:

impl<'a> EfficientParser<'a> {
    fn handle_error(&self, error: ParseError) -> Result<Value> {
        match error.kind {
            ErrorKind::UnexpectedEof => {
                if self.recovery_enabled {
                    self.attempt_recovery()
                } else {
                    Err(error)
                }
            }
            ErrorKind::InvalidNumber => {
                self.skip_invalid_number()?;
                Ok(Value::Null)
            }
            _ => Err(error),
        }
    }
}

These techniques have served me well in building high-performance JSON parsers. The key is to understand your specific requirements and choose the appropriate optimizations accordingly.

Testing is crucial when implementing these optimizations. Each technique should be thoroughly verified:

#[cfg(test)]
mod tests {
    #[test]
    fn test_borrowed_parsing() {
        let input = br#"{"name":"test","numbers":[1,2,3]}"#;
        let mut parser = BorrowedParser::new(input);
        let result = parser.parse().unwrap();
        assert_eq!(result["name"].as_str(), Some("test"));
    }
}