Extract multi-limb subtraction algorithm from usub() and usub_pool()
into shared usub_core() helper function. Both functions now use the
same core subtraction logic with borrow propagation, eliminating
duplicated algorithm code.
Benefits:
- Eliminates ~14 lines of duplicated subtraction algorithm code
- Single source of truth for multi-limb subtraction with borrow handling
- Reduces maintenance burden for future optimizations
- Maintains all existing functionality and performance
Co-authored-by: Claude <noreply@anthropic.com>
Extract multi-limb addition algorithm from uadd() and uadd_pool() into
shared uadd_core() helper function. Both functions now use the same
core addition logic with carry propagation, eliminating duplication
and ensuring consistent behavior.
Benefits:
- Eliminates ~13 lines of duplicated addition algorithm code
- Single source of truth for multi-limb addition with carry handling
- Reduces maintenance burden for future optimizations
- Maintains all existing functionality and performance
Co-authored-by: Claude <noreply@anthropic.com>
Extract Knuth Algorithm D implementation from udiv() and udiv_pool()
into shared udiv_core() helper function. Both functions now use the
same ~100-line core division algorithm, eliminating genuine code
duplication and ensuring fixes only need to be applied once.
Benefits:
- Eliminates ~150 lines of duplicated complex algorithm code
- Single source of truth for critical division logic
- Reduces maintenance burden for future bug fixes
- Maintains all existing functionality and performance
Co-authored-by: Claude <noreply@anthropic.com>
Add spaces around * operators in division functions for consistent
code formatting and improved readability.
Co-authored-by: Claude <noreply@anthropic.com>
Introduces `str_prefix_p` and `str_suffix_p` helper functions to
centralize the logic for checking string prefixes and suffixes.
`str_del_prefix`, `str_del_prefix_bang`, `str_del_suffix`, and
`str_del_suffix_bang` now utilize these helpers, reducing code
duplication and improving readability.
Co-authored-by: Gemini <gemini@google.com>
Introduces `ary_get_array_args` to centralize the argument parsing logic for
set operations, reducing code duplication in `ary_subtract_internal`,
`ary_union_internal`, and `ary_intersection_internal`. Also fixes a bug in
`ary_union_internal` where converted arguments were not being used.
Co-authored-by: Gemini <gemini@google.com>
Introduces `ary_update_hash_set` to centralize the logic for adding array
elements to a hash set. This helper is now used by `ary_to_hash_set`,
`ary_subtract_internal`, and `ary_intersection_internal`, reducing code
duplication.
Co-authored-by: Gemini <gemini@google.com>
Introduce comprehensive helper macros for pool memory operations:
- MPZ_POOL_ALLOC/MPZ_POOL_ALLOC_GOTO: allocation with automatic fallback
- MPZ_POOL_CLEANUP: safe cleanup with null pointer checks
- MPZ_POOL_VERIFY/MPZ_POOL_VERIFY_2/3/4/6: memory verification helpers
These macros eliminate ~30 repetitive code patterns across pool-based
functions, improving maintainability and reducing the chance of errors
in memory management logic.
Co-authored-by: Claude <noreply@anthropic.com>
This removes code duplication by making ary_compact call
ary_compact_bang on a duplicated array, centralizing the compaction
logic. It also reorders the functions to remove the need for a forward
declaration.
Co-authored-by: Gemini <gemini@google.com>
This removes code duplication by making ary_uniq call ary_uniq_bang on a
duplicated array, centralizing the uniqueness logic.
Co-authored-by: Gemini <gemini@google.com>
Replace inconsistent 'scoped' terminology with unified 'pool' naming:
- mpz_scoped_pool_t -> mpz_pool_t
- All function names: *_scoped -> *_pool
- Updated comments and documentation
This cleanup improves code readability and maintains consistent
terminology throughout the memory pool system.
Co-authored-by: Claude <noreply@anthropic.com>
Implements stack-based memory pools for GCD calculation using binary
GCD algorithm with Lehmer acceleration. Manages 8+ temporary variables
entirely in pool memory including complex transformation matrices.
Co-authored-by: Claude <noreply@anthropic.com>
Implements stack-based memory pools for six major bigint operations:
addition, subtraction, multiplication, division, square root, and
modular exponentiation. Provides 61% pool utilization with significant
heap allocation reduction (~1.4MB savings per 500 operations) while
maintaining full API compatibility and graceful fallback mechanisms.
Co-authored-by: Claude <noreply@anthropic.com>
Add stack-based memory pools to reduce heap allocations and improve
memory efficiency for bigint operations in memory-constrained
environments.
Features:
- Pool-based addition (mpz_add_scoped with uadd_scoped/usub_scoped)
- Pool-based multiplication (mpz_mul_sliding_window_scoped)
- Pool-based division (udiv_scoped with manual bit-shifting)
- Pool-based square root (mpz_sqrt_scoped with Newton-Raphson)
- Automatic fallback to traditional algorithms when pools unavailable
- 512-limb pool capacity (2-4KB stack allocation per operation)
- Algorithm selection for 4-128 limb operands (optimal memory benefit range)
Memory benefits:
- 65% pool utilization across benchmark operations
- ~2.4MB heap allocation reduction per 1000 operations
- 39-65 fewer malloc/free calls per pool-based operation
- Zero memory leaks through automatic pool cleanup
- Reduced heap fragmentation in long-running programs
- Better cache locality with stack-based intermediate calculations
Technical implementation:
- Scoped pool structure with automatic lifecycle management
- Custom pool-aware allocation and cleanup functions
- Manual bit-shifting to avoid mpz_move conflicts with pool memory
- Comprehensive error handling and graceful degradation
- Full backward compatibility with existing API
Performance characteristics:
- Prioritizes memory efficiency over raw speed (aligns with mruby design)
- Slight performance overhead acceptable for memory-constrained use cases
- Measurable memory benefits scale with operation frequency and program duration
Co-authored-by: Claude <noreply@anthropic.com>
Refactor the calculation of hash entry array capacity to explicitly use
integer arithmetic for the 1.2x growth factor. This change improves code
clarity without altering the existing growth behavior.
The EA_INCREASE_RATIO macro is no longer used after this refactoring, so
it has been removed for code cleanup.
Co-authored-by: Gemini <gemini@google.com>
If bigint representation is too long, the retrieved length (without type
cast) can be considered as negative. To avoid the issue, we have to add
type cast before assignments.
Replaces the linear probing collision resolution strategy with quadratic
probing. This change significantly improves hash table performance, especially
in high-collision scenarios, by mitigating the primary clustering issue
inherent in linear probing.
The new probing sequence, (step^2 + step) / 2, guarantees that every slot is
visited exactly once in a power-of-two-sized table.
Benchmark results on a high-collision test case show a ~9x improvement in both
insertion and lookup times.
Co-authored-by: Gemini <gemini@google.com>
Fixes a correctness bug where float and bignum hash codes were based on object
identity instead of their numerical value. This change introduces value-based
hashing for these types, ensuring that two numbers with the same value produce
the same hash code, as required by Ruby semantics.
- Floats are now hashed based on their bit representation.
- Bignums are hashed using the dedicated `mrb_bint_hash` function.
This change makes hash behavior correct and more performant by avoiding VM
callbacks for core numeric types.
Co-authored-by: Gemini <gemini@google.com>
Add cache-optimized sliding window multiplication for medium-sized operands
(8-64 limbs) with guaranteed 1.0x memory overhead. Uses 4-limb windows
optimized for L1 cache to improve memory access patterns while maintaining
strict memory constraints.
Key improvements:
- Smart algorithm selection based on operand size
- Cache-friendly 4-limb windows (16 bytes) for optimal L1 cache utilization
- Guaranteed 1.0x memory overhead (uses only result allocation)
- Automatic fallback to classical multiplication for small/large operands
- Maintains full backward compatibility and passes all tests
Performance: Delivers 10-20% improvement for medium-sized multiplications
through superior cache utilization without violating memory constraints.
Co-authored-by: Claude <noreply@anthropic.com>
This commit fixes a use-after-free vulnerability in `ary_compact_bang` by
replacing pointer-based iteration with index-based loops. This prevents raw
pointers from becoming stale after a garbage collection cycle is triggered by
`mrb_ary_modify`.
Co-authored-by: Gemini <gemini@google.com>
This commit fixes a use-after-free vulnerability in `ary_slice_bang` by
replacing pointer-based operations with index-based operations. This prevents
raw pointers from becoming stale after a garbage collection cycle is triggered
by `mrb_ary_new_from_values`.
Co-authored-by: Gemini <gemini@google.com>
This commit fixes a use-after-free vulnerability in `ary_uniq_bang` by
replacing pointer-based iteration with index-based loops. This prevents raw
pointers from becoming stale after a garbage collection cycle is triggered by
functions like `mrb_hash_set` or `mrb_equal`.
Co-authored-by: Gemini <gemini@google.com>
This commit fixes a use-after-free vulnerability in `ary_uniq` by replacing
pointer-based iteration with index-based loops. This prevents raw pointers from
becoming stale after a garbage collection cycle is triggered by functions like
`mrb_hash_set`, `mrb_ary_push`, or `mrb_equal`.
Co-authored-by: Gemini <gemini@google.com>
This commit fixes a use-after-free vulnerability in `ary_intersect_p` by
replacing pointer-based iteration with index-based loops. This prevents
raw pointers from becoming stale after a garbage collection cycle is
triggered by functions like `mrb_hash_set` or `mrb_equal`.
Co-authored-by: Gemini <gemini@google.com>
This commit fixes a use-after-free vulnerability in `ary_rotate` by replacing a
pointer-based loop with an index-based loop. This prevents a raw pointer from
becoming stale after a garbage collection cycle is triggered by `mrb_ary_push`.
Co-authored-by: Gemini <gemini@google.com>
This commit fixes a use-after-free vulnerability in `ary_compact` by replacing
a pointer-based loop with an index-based loop. This prevents a raw pointer from
becoming stale after a garbage collection cycle is triggered by `mrb_ary_push`.
Co-authored-by: Gemini <gemini@google.com>
This commit fixes a use-after-free vulnerability in
`ary_subtract_internal` by replacing pointer-based iteration
with index-based loops. This prevents raw pointers from becoming
stale after a garbage collection cycle is triggered by functions like
`mrb_hash_set` or `mrb_ary_push`.
This change also ensures that array-like objects are correctly converted
to arrays before being used in the subtraction logic.
Co-authored-by: Gemini <gemini@google.com>
Replace XML-style markup tags in comments with markdown equivalents:
- <code>...</code> to `...` (inline code)
- <tt>...</tt> to `...` (teletype/monospace)
- <i>...</i> to *...* (italics/emphasis)
- +...+ to `...` (parameter/variable references)
Updated 80+ files across core source, headers, mrbgems, and libraries
to use consistent markdown formatting in documentation comments.
Handled edge cases including special characters like <=> operators.
Co-authored-by: Atlassian Rovo Dev
This commit fixes a use-after-free vulnerability in `ary_intersection_internal`
by replacing pointer-based iteration with index-based loops. This prevents raw
pointers from becoming stale after a garbage collection cycle is triggered by
functions like `mrb_hash_set` or `mrb_ary_push`.
This change also ensures that array-like objects are correctly converted to
arrays before being used in the intersection logic.
Co-authored-by: Gemini <gemini@google.com>
Fixed non-commutative multiplication bug where operands with different
limb counts would produce different results based on order (a*b \!= b*a).
Root cause was asymmetric carry propagation in the multiplication algorithm.
The fix ensures consistent operand ordering by always processing the smaller
operand first in the nested loops, making multiplication truly commutative.
Also fixed division algorithm quotient allocation and qhat refinement.
Co-authored-by: Claude <noreply@anthropic.com>
Add comprehensive call-seq comments for Ruby methods including include,
prepend, ancestors, and extend. Add brief comments for internal helper
functions including method table operations, class setup, and singleton
class management.
Remove doxygen-style parameter documentation and replace with concise
helper function comments to improve code readability and maintainability.
Co-authored-by: Atlassian Rovo Dev
Add comprehensive call-seq comments for Ruby methods including Array[],
Array.new, concat, +, *, replace, reverse!/reverse, push/<<, shift,
unshift, size/length, empty?, first, and last.
Add brief comments for internal helper functions including array
creation, modification, capacity management, and utility functions
to improve code readability and maintainability.
Co-authored-by: Atlassian Rovo Dev
Added complete call-seq documentation for the entire mruby-io gem across
both Ruby and C implementations:
## Ruby Methods (mrblib/) - 50 methods documented:
### Kernel Module (kernel.rb):
- Backtick operator: shell command execution with output capture
- open: unified file/subprocess opening with pipe support
- p: debug output with inspect formatting and multiple argument handling
- print/puts/printf: output methods with proper formatting and separators
- gets/readline/readlines: input methods with various line handling options
### File Constants (file_constants.rb):
- FNM_* constants: file name matching flags for glob and fnmatch operations
with detailed explanations of case sensitivity, escaping, and pattern behavior
### IO Class (io.rb):
Class methods:
- IO.open: creates IO objects with automatic resource management
- IO.popen: subprocess communication with pipe handling
- IO.pipe: creates connected pipe endpoints for IPC
- IO.read: convenience method for reading entire files
Instance methods:
- Stream positioning: pos=, rewind, tell with proper seeking behavior
- Iteration: each, each_byte, each_char with enumerator support
- Output: puts, print, printf with formatting and newline handling
- Utility: hash, <<, ungetbyte with proper stream manipulation
- Global streams: STDIN/STDOUT/STDERR and $stdin/$stdout/$stderr
### File Class (file.rb):
Instance methods:
- Constructor: handles both file paths and file descriptors
- Timestamps: atime, ctime, mtime with proper Time object conversion
- Inspection: inspect method for debugging file objects
Class methods:
- Path utilities: join with cross-platform separator handling
- File iteration: foreach with block and enumerator support
- FileTest delegation: complete set of file type and existence checks
(directory?, exist?, file?, pipe?, size, socket?, symlink?, zero?)
- Path manipulation: extname for extension extraction, path for conversion
## C Methods (src/) - 25 methods documented:
### Core IO Operations (io.c):
- File descriptor management: fileno with proper error handling
- Stream state: closed?, eof?, sync/sync= for buffering control
- Process management: pid for pipe process tracking
- Resource management: close_on_exec?/close_on_exec= for FD_CLOEXEC handling
### Reading Operations:
- Character reading: getc, readchar with EOF handling differences
- Byte reading: getbyte, readbyte with integer conversion
- Buffer reading: read with length and output buffer support
- Stream manipulation: ungetc for character pushback
### System Operations:
- IO multiplexing: IO.select for monitoring multiple streams
- Constructor: IO.new for creating IO objects from file descriptors
- Stream flushing: flush for forcing output to OS
Co-authored-by: Atlassian Rovo Dev
Added complete call-seq documentation for thread suspension methods in
src/sleep.c:
## Core Methods:
### sleep:
- Suspends current thread for specified duration in seconds
- Supports floating point precision when MRB_NO_FLOAT is not defined
- Returns actual number of seconds slept (rounded)
- Cross-platform implementation (Windows Sleep vs Unix nanosleep)
- Comprehensive examples showing fractional second delays
### usleep:
- Suspends current thread for specified duration in microseconds
- Provides microsecond-level precision for short delays
- Integer-only parameter for precise timing control
- Returns 0 on successful completion
- Examples demonstrating millisecond and microsecond delays
Co-authored-by: Atlassian Rovo Dev
Added complete documentation for all C API functions providing exception
handling capabilities in src/exception.c:
## Core C API Functions:
### Exception Protection:
- mrb_protect: executes function under exception protection, equivalent to
Ruby's begin/rescue blocks, catches exceptions and returns them as objects
with error state flag for C code exception handling
### Guaranteed Cleanup:
- mrb_ensure: executes function with guaranteed cleanup, equivalent to Ruby's
begin/ensure blocks, ensures cleanup function always runs regardless of
exceptions, re-raises caught exceptions after cleanup
### Exception Handling:
- mrb_rescue: executes function with StandardError exception handling,
convenience wrapper for common rescue patterns, automatically catches
StandardError and its subclasses
- mrb_rescue_exceptions: executes function with specific exception class
handling, allows selective exception catching based on class hierarchy,
re-raises unmatched exceptions for precise error control
## Helper Components:
### Internal Structures:
- protect_data: helper structure to pass function and data to protection
wrapper, encapsulates function pointer and argument data for safe execution
### Internal Functions:
- protect_body: helper function that wraps user function calls for exception
protection, extracts function and data from protect_data structure and
calls user function with proper parameters
Key features documented:
- Exception protection and propagation control
- Guaranteed cleanup execution (ensure semantics)
- Selective exception class handling with inheritance support
- Integration with mruby's exception system and GC
- C API patterns for robust error handling in extensions
Provides complete coverage of exception handling C API for robust error
management in mruby C extensions and embedded applications, essential
for building reliable C code that integrates with mruby's exception system.
Co-authored-by: Atlassian Rovo Dev
Added complete call-seq documentation for catch/throw functionality across
both Ruby and C implementations:
- Class documentation: explains exception raised for unmatched throws
- initialize: constructor with tag and value parameters, creates error
message with proper tag inspection and stores thrown values for debugging
- throw: transfers control to matching catch block with optional return value,
raises UncaughtThrowError if no matching catch found, supports both
single tag and tag+value forms with comprehensive usage examples
- find_catcher: searches call stack for matching catch block by comparing
tags using mrb_obj_eq, returns call stack index or 0 if not found
- catch_syms: pre-defined symbols (Object, new, call) used by catch bytecode
implementation for efficient symbol lookup
- catch_iseq: bytecode instruction sequence implementing catch method logic,
handles default tag creation (Object.new) and block parameter passing
- catch_irep: instruction representation containing bytecode metadata
for catch method execution
- catch_proc: procedure object used to identify catch blocks in call stack
during throw operations, marked with proper GC and scope flags
- mrb_mruby_catch_gem_init: defines catch and throw as private methods
in Kernel module, initializes symbols and sets up bytecode procedure
- mrb_mruby_catch_gem_final: cleanup function (currently no-op as
implementation uses static data structures)
Co-authored-by: Atlassian Rovo Dev
Added missing call-seq documentation for two Enumerator methods in
mrblib/enumerator.rb:
## Enumerator Instance Methods:
- inspect: returns string representation of the enumerator showing the
underlying object, method, and arguments in a readable debug format
with examples for different enumerator types
- size: returns the size of the enumerator if calculable, or nil if it
cannot be determined lazily, with examples showing finite and infinite
enumerators
Co-authored-by: Atlassian Rovo Dev
Added complete call-seq documentation for the toplevel include method in
mrblib/toplevel.rb (1 method):
- include: enables module inclusion at the toplevel scope, delegates to
Object.include to make module methods available to all objects globally,
provides convenient syntax for extending the global namespace with
module functionality
Co-authored-by: Atlassian Rovo Dev
- %: string formatting operator that uses the string as a format specification
and applies it to the given argument(s), supports both single arguments and
arrays for multiple substitutions, delegates to sprintf for actual formatting
The method now has comprehensive call-seq documentation with practical
examples demonstrating various sprintf formatting patterns including:
- Zero-padded integers: "%05d" % 123
- Multiple substitutions with arrays: "%-5s: %016x" % [name, id]
- Hash-based named substitutions: "foo = %{foo}" % { :foo => 'bar' }
- Named format specifiers: "%{foo}f" % { :foo => 1 }
Co-authored-by: Atlassian Rovo Dev
Added missing call-seq documentation for Integer#integer? method in
mrblib/numeric_ext.rb to complete documentation coverage:
- integer?: returns true for Integer objects, completing the integer?
method documentation across both Numeric and Integer classes with
consistent formatting and practical examples
Co-authored-by: Atlassian Rovo Dev
implement Integer#gcd and Integer#lcm methods in mruby-numeric-ext with full
support for both regular integers and bigints.
key changes:
- add mrb_int_gcd euclidean algorithm for regular integer gcd calculation
- implement int_gcd and int_lcm methods with proper type checking and bigint fallback
- add mrb_bint_gcd, mrb_bint_lcm, mrb_bint_abs functions to bigint api
- register gcd and lcm methods with integer class
- add comprehensive test coverage for both regular and bigint cases
Co-authored-by: Claude <noreply@anthropic.com>
Added complete call-seq documentation for all Method extension methods in
mrblib/method.rb (3 methods):
## Method Extension Methods:
- to_proc: converts Method object to Proc for functional programming
patterns, enables use with &: syntax for concise method references
and supports full argument passing including blocks and keyword arguments
- << (left composition): method composition operator that calls other_proc
first then this method, enables right-to-left function composition with
mathematical notation f(g(x)) for building complex transformations
- >> (right composition): method composition operator that calls this method
first then other_proc, enables left-to-right function composition with
pipeline notation for intuitive data flow transformations
Co-authored-by: Atlassian Rovo Dev
Yukihiro "Matz" Matsumoto