The hardware and bandwidth for this mirror is donated by METANET, the Webhosting and Full Service-Cloud Provider.
If you wish to report a bug, or if you are interested in having us mirror your free-software or open-source project, please feel free to contact us at mirror[@]metanet.ch.
n_workers = 1 per process for
parallel execution across series. Existing fork warnings now clarify
that reducing the thread count cannot undo inherited library state and
does not guarantee safe fork-based execution.mstomp):
Added native high-performance C++ engine (mstomp_rcpp) with
multi-threading via RcppThread, properly sorting
must/exclusion dimensions, and fixing historical edge cases where must
dimensions could be omitted from accumulated distances. Delivers ~197x
speedup over legacy pure R execution.na_strategy & na.rm):
Implemented complete missing/non-finite value support across
mov_mean(), mov_sum(), mov_var(),
mov_std(), mov_min(), mov_max(),
movmean_std(), and muinvn() with explicit
na_strategy = c("window_na", "remove", "error") and
standard na.rm argument compatibility. Default
"window_na" returns NA_real_ strictly for
windows intersecting non-finite values without corrupting adjacent valid
windows or stopping execution.mass):
Extended multi-threading via RcppThread to all MASS
variants (v2, weighted,
non_normalized, absolute) in
mass() and C++ backend (mass2_rcpp,
mass_weighted_rcpp, mass_absolute_rcpp),
matching mass3_rcpp_parallel with identical numerical
output.mpdist_vect_rcpp and
mpdist_simple_rcpp) with multi-threaded parallel execution
via RcppThread.std::nth_element, replacing expensive R matrix and data
frame allocations and providing massive speedups (over 10x-100x).mpdist() API: Exported
mpdist(ref_data, query_data, window_size, type = c("simple", "vector"), thr = 0.05, n_workers = 1)
in R with dedicated unit test suite.inst/cuda/rfcp_gpu_poc.cu.rfcp_top_k() via query_block_size, dividing
long query streams into bounded blocks while preserving exact numeric
equivalence to monolithic execution.progress_callback reporting structured events
("round_start", "block_done",
"round_done") with execution timings and local block/Plato
metrics.checkpoint_callback and resume_state,
supporting idempotent recovery from both intra-round (query block) and
inter-round (Plato) interruptions.adaptive_max_freq support to
rfcp_top_k(), dynamically rescaling subsequent frequencies
based on observed Plato support (count of positive self-join neighbors
with distance below \(\sqrt{2 \cdot
\text{window\_size}}\)) with configurable min_freq
floor.rfcp_top_k(), an iterative Top-K Plato discovery
function for Relative Frequency Contrast Profiles (RFCP) that uncovers
multiple distinct contrasting patterns between a positive and negative
time series.[start - exclusion_radius, start + window_size - 1 + exclusion_radius])
and fusing overlapping intervals with NA barriers to
prevent boundary artifacts.max_freq specification across
Plato iterations via vectors
(e.g. max_freq = c(10, 3)).rfcp(..., backend = "cuda"), with full support for finite
and NA-barrier series, query subsetting, and full-profile matrix
extraction (return_profiles = TRUE).cub::DeviceSegmentedRadixSort and a
specialized CUDA exclusion kernel, eliminating PCIe bandwidth
bottlenecks and delivering up to 55x speedup over CPU-sorting GPU
baselines and over 12x speedup compared to single-threaded CPU
execution.inst/cuda/ and linked conditionally
via MATRIXPROFILER_ENABLE_CUDA, preserving standard
CUDA-free CRAN compatibility.mpx(..., backend = "cuda"), including finite and
NA-aware inputs.inst/cuda/ while preserving the default CUDA-free CRAN
build.query_begin, derives the tile size from
the query count and effective worker count, and reports
query_rows_per_task, n_tasks, and
effective_workers for diagnostics while preserving the
public rfcp() API.Added rfcp(), an exact parallel NA-aware Relative
Frequency Contrast Profile implementation with deterministic greedy
non-overlapping neighbor ranks, fixed-frequency RMSC semantics,
restartable positive-query blocks, and an allocation-guarded
full-profile validation mode.
Added the fused native
rfcp_na_segmented_native_rcpp_parallel() kernel, which
shares rolling normalization across AA and AB computations, initializes
large blocks with a MASS-style FFT convolution, advances subsequent
distance profiles with a STOMP-style covariance recurrence, respects
non-finite barriers and non-normalizable windows, and avoids
materializing the pairwise distance matrix.
Added independently selectable native finite-block segmentation
for NA-aware MPX self-joins and AB-joins through
na_strategy = "segmented_native" in mpx(),
while retaining the monolithic implementation as the default.
Added native diagonal-tile sampling for
s_size < 1, with explicit partial results
and adaptive tile subdivision based on the configured parallel thread
count.
Added global-coordinate reduction of native segmented profiles and indices, including cross-segment AB comparisons and exclusion-zone handling for AA joins.
Optimized native segmented scheduling for highly unbalanced segment lengths, added cache-bounded rectangular blocks for exact AA joins, and allowed it to mask constant or otherwise non-normalizable windows without reverting to the monolithic NA-aware kernel.
Set the native exact-AA block default to 8,192 windows and
documented MATRIXPROFILER_NATIVE_AA_BLOCK_SIZE for
cache-tuning large parallel NA-aware self-joins without changing the
public mpx() API.
Validated the native segmented implementation on the full
fixture: exact AA and AB runs completed with
partial = FALSE, identical validity masks, and substantial
wall-time reductions compared with the previous native and monolithic
NA-aware paths.
Added regression and stress coverage against the monolithic NA-aware MPX implementation and STAMP for non-finite barriers, one-window segments, distance, correlation, and sampled computations.
Clarified the MPX s_size semantics: values below
1 retain randomized anytime sampling, while
s_size = 1 processes all diagonals in monotone order and
may yield a less representative partial result if interrupted.
Added a numerically guarded finite fast path for NA-aware MPX and MPXAB, preserving the stable normalization path for constant or large-offset windows.
Reused parallel AB/BA worker scratch buffers per executor thread and limited mutex merges to ranges touched by each task.
Avoided allocating and writing profile-index vectors in parallel
self- and AB-joins when idxs = FALSE.
Added an opt-in AB/BA worker profiler with per-task counts for pairs, invalid blocks, scratch resets, merges, mutex wait, and observed threads.
Added a conservative native restart path that skips dense invalid blocks in parallel NA-aware AB/BA joins while preserving the original recurrence for sparse barriers.
Kept complete NA-aware AB/BA joins in monotone diagonal order to reduce parallel scratch resets and merges; sampled joins retain randomized work order.
Added reproducible fixture benchmarks and a persistent optimization workplan for NA-aware segmentation and parallel reductions.
SIGFPE crashes in parallel STOMP and MPX for
computations with fewer than 100 query windows or diagonals.left_right_profile native argument.s_size and added validation
for values outside the [0, 1] interval.mpx_na_rcpp() implementation, which
excludes windows containing NA, NaN, or
infinite samples while allowing later valid windows to recover, and
optimized its quadratic kernel to avoid costly Rcpp proxy accesses.mpx_na_rcpp_parallel() with the same missing-data
semantics as the serial implementation and support for partial
computations through s_size; its worker kernel uses direct
contiguous storage without R API calls.mpxab_na_rcpp() AB-join for
independently masking non-finite windows in both input series, with
direct storage access in its quadratic kernel.mpxab_na_rcpp_parallel() with matching
bidirectional masks and partial-computation behavior, using direct
contiguous storage inside its workers.mpx() to route self-joins and AB-joins
automatically to the serial or parallel missing-data implementation
whenever either input contains NA, NaN, or
infinite values.s_size, and calling unsafe R APIs from
worker threads.s_size; its diagonal
computation now shares the validated NA-aware MPX recurrence while
serial PRE-SCRIMP still seeds sampled distance profiles.s_size in the R-to-C++ call, rejecting unequal input
lengths, and failing to mask non-finite windows independently in both
series.Rcpp as specified by the PR #15 from Dirk @eddelbuetteltsmp.These binaries (installable software) and packages are in development.
They may not be fully stable and should be used with caution. We make no claims about them.