org.apache.ignite.ml.math.distributed

Class CacheUtils

java.lang.Object

org.apache.ignite.ml.math.distributed.CacheUtils

Direct Known Subclasses:

BlockMatrixStorage, BlockVectorStorage, SparseDistributedMatrixStorage, SparseDistributedVectorStorage

public class CacheUtils
extends Object

Distribution-related misc. support. TODO: IGNITE-5102, fix sparse key filters.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	CacheUtils.CacheEntry<K,V> Cache entry support.

Constructor Summary

Constructors

Constructor and Description
CacheUtils()

Method Summary

Modifier and Type	Method and Description
static <A> Collection<A>	bcast(String cacheName, IgniteCallable<A> call)
static <A> Collection<A>	bcast(String cacheName, Ignite ignite, IgniteCallable<A> call) Broadcast callable to data nodes of given cache.
static void	bcast(String cacheName, Ignite ignite, IgniteRunnable run)
static void	bcast(String cacheName, IgniteRunnable run) Broadcast runnable to data nodes of given cache.
static <K,V,A> A	distributedFold(String cacheName, IgniteBiFunction<javax.cache.Cache.Entry<K,V>,A,A> folder, IgnitePredicate<K> keyFilter, BinaryOperator<A> accumulator, IgniteSupplier<A> zeroValSupp) Distributed version of fold operation.
static <K,V,A> Collection<A>	fold(String cacheName, IgniteBiFunction<CacheUtils.CacheEntry<K,V>,A,A> folder) Currently fold supports only commutative operations.
static <K,V,A> Collection<A>	fold(String cacheName, IgniteBiFunction<CacheUtils.CacheEntry<K,V>,A,A> folder, IgnitePredicate<K> keyFilter) Currently fold supports only commutative operations.
protected static <K,V> void	foreach(String cacheName, IgniteConsumer<CacheUtils.CacheEntry<K,V>> fun, IgnitePredicate<K> keyFilter)
protected static <K> ClusterGroup	getClusterGroupForGivenKey(String cacheName, K k)
static Ignite	ignite() Gets local Ignite instance.
static <K,V> void	map(String cacheName, KeyMapper<K> keyMapper, ValueMapper<V> valMapper, IgniteFunction<Double,Double> mapper)
static <K,V> double	max(String cacheName, KeyMapper<K> keyMapper, ValueMapper<V> valMapper)
static <K,V> double	min(String cacheName, KeyMapper<K> keyMapper, ValueMapper<V> valMapper)
static <K,V,A,W> A	reduce(String cacheName, Ignite ignite, IgniteTriFunction<W,javax.cache.Cache.Entry<K,V>,A,A> acc, IgniteSupplier<W> supp, IgniteSupplier<Iterable<javax.cache.Cache.Entry<K,V>>> entriesGen, IgniteBinaryOperator<A> comb, IgniteSupplier<A> zeroValSupp) Distributed version of fold operation.
static <K,V,A,W> A	reduce(String cacheName, IgniteTriFunction<W,javax.cache.Cache.Entry<K,V>,A,A> acc, IgniteSupplier<W> supp, IgniteSupplier<Iterable<javax.cache.Cache.Entry<K,V>>> entriesGen, IgniteBinaryOperator<A> comb, IgniteSupplier<A> zeroValSupp) Distributed version of fold operation.
static <K,V> void	sparseMap(UUID matrixUuid, IgniteDoubleFunction<Double> mapper, String cacheName)
static <K,V> void	sparseMapForVector(UUID vectorUuid, IgniteDoubleFunction<V> mapper, String cacheName)
static <K,V> double	sparseMax(UUID matrixUuid, String cacheName)
static <K,V> double	sparseMin(UUID matrixUuid, String cacheName)
static <K,V> double	sparseSum(UUID matrixUuid, String cacheName)
static <K,V> double	sum(String cacheName, KeyMapper<K> keyMapper, ValueMapper<V> valMapper)
static <K,V> void	update(String cacheName, Ignite ignite, IgniteBiFunction<Ignite,javax.cache.Cache.Entry<K,V>,Stream<javax.cache.Cache.Entry<K,V>>> fun, IgniteSupplier<Set<K>> keysGen)
static <K,V> void	update(String cacheName, Ignite ignite, IgniteConsumer<javax.cache.Cache.Entry<K,V>> fun, IgniteSupplier<Set<K>> keysGen)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

CacheUtils

public CacheUtils()

Method Detail

ignite

public static Ignite ignite()

Gets local Ignite instance.

getClusterGroupForGivenKey

protected static <K> ClusterGroup getClusterGroupForGivenKey(String cacheName,
                                                             K k)

Type Parameters:

K - Key type.

Parameters:

cacheName - Cache name.

k - Key into the cache.

Returns:

Cluster group for given key.

sum

public static <K,V> double sum(String cacheName,
                               KeyMapper<K> keyMapper,
                               ValueMapper<V> valMapper)

Type Parameters:

K - Cache key object type.

V - Cache value object type.

Parameters:

cacheName - Cache name.

keyMapper - KeyMapper to validate cache key.

valMapper - ValueMapper to obtain double value for given cache key.

Returns:

Sum of the values obtained for valid keys.

sparseSum

public static <K,V> double sparseSum(UUID matrixUuid,
                                     String cacheName)

Parameters:

matrixUuid - Matrix UUID.

Returns:

Sum obtained using sparse logic.

min

public static <K,V> double min(String cacheName,
                               KeyMapper<K> keyMapper,
                               ValueMapper<V> valMapper)

Type Parameters:

K - Cache key object type.

V - Cache value object type.

Parameters:

cacheName - Cache name.

keyMapper - KeyMapper to validate cache key.

valMapper - ValueMapper to obtain double value for given cache key.

Returns:

Minimum value for valid keys.

sparseMin

public static <K,V> double sparseMin(UUID matrixUuid,
                                     String cacheName)

Parameters:

matrixUuid - Matrix UUID.

Returns:

Minimum value obtained using sparse logic.

sparseMax

public static <K,V> double sparseMax(UUID matrixUuid,
                                     String cacheName)

Parameters:

matrixUuid - Matrix UUID.

Returns:

Maximum value obtained using sparse logic.

max

public static <K,V> double max(String cacheName,
                               KeyMapper<K> keyMapper,
                               ValueMapper<V> valMapper)

Type Parameters:

K - Cache key object type.

V - Cache value object type.

Parameters:

cacheName - Cache name.

keyMapper - KeyMapper to validate cache key.

valMapper - ValueMapper to obtain double value for given cache key.

Returns:

Maximum value for valid keys.

map

public static <K,V> void map(String cacheName,
                             KeyMapper<K> keyMapper,
                             ValueMapper<V> valMapper,
                             IgniteFunction<Double,Double> mapper)

Type Parameters:

K - Cache key object type.

V - Cache value object type.

Parameters:

cacheName - Cache name.

keyMapper - KeyMapper to validate cache key.

valMapper - ValueMapper to obtain double value for given cache key.

mapper - Mapping IgniteFunction.

sparseMap

public static <K,V> void sparseMap(UUID matrixUuid,
                                   IgniteDoubleFunction<Double> mapper,
                                   String cacheName)

Parameters:

matrixUuid - Matrix UUID.

mapper - Mapping IgniteFunction.

foreach

protected static <K,V> void foreach(String cacheName,
                                    IgniteConsumer<CacheUtils.CacheEntry<K,V>> fun,
                                    IgnitePredicate<K> keyFilter)

Type Parameters:

K - Cache key object type.

V - Cache value object type.

Parameters:

cacheName - Cache name.

fun - An operation that accepts a cache entry and processes it.

keyFilter - Cache keys filter.

update

public static <K,V> void update(String cacheName,
                                Ignite ignite,
                                IgniteBiFunction<Ignite,javax.cache.Cache.Entry<K,V>,Stream<javax.cache.Cache.Entry<K,V>>> fun,
                                IgniteSupplier<Set<K>> keysGen)

Type Parameters:

K - Cache key object type.

V - Cache value object type.

Parameters:

cacheName - Cache name.

fun - An operation that accepts a cache entry and processes it.

ignite - Ignite.

keysGen - Keys generator.

update

public static <K,V> void update(String cacheName,
                                Ignite ignite,
                                IgniteConsumer<javax.cache.Cache.Entry<K,V>> fun,
                                IgniteSupplier<Set<K>> keysGen)

Type Parameters:

K - Cache key object type.

V - Cache value object type.

Parameters:

cacheName - Cache name.

fun - An operation that accepts a cache entry and processes it.

ignite - Ignite.

keysGen - Keys generator.

fold

public static <K,V,A> Collection<A> fold(String cacheName,
                                         IgniteBiFunction<CacheUtils.CacheEntry<K,V>,A,A> folder)

Currently fold supports only commutative operations.

Type Parameters:

K - Cache key object type.

V - Cache value object type.

A - Fold result type.

Parameters:

cacheName - Cache name.

folder - Fold function operating over cache entries.

Returns:

Fold operation result.

fold

public static <K,V,A> Collection<A> fold(String cacheName,
                                         IgniteBiFunction<CacheUtils.CacheEntry<K,V>,A,A> folder,
                                         IgnitePredicate<K> keyFilter)

Currently fold supports only commutative operations.

Type Parameters:

K - Cache key object type.

V - Cache value object type.

A - Fold result type.

Parameters:

cacheName - Cache name.

folder - Fold function operating over cache entries.

Returns:

Fold operation result.

distributedFold

public static <K,V,A> A distributedFold(String cacheName,
                                        IgniteBiFunction<javax.cache.Cache.Entry<K,V>,A,A> folder,
                                        IgnitePredicate<K> keyFilter,
                                        BinaryOperator<A> accumulator,
                                        IgniteSupplier<A> zeroValSupp)

Distributed version of fold operation.

Parameters:

cacheName - Cache name.

folder - Folder.

keyFilter - Key filter.

accumulator - Accumulator.

zeroValSupp - Zero value supplier.

reduce

public static <K,V,A,W> A reduce(String cacheName,
                                 Ignite ignite,
                                 IgniteTriFunction<W,javax.cache.Cache.Entry<K,V>,A,A> acc,
                                 IgniteSupplier<W> supp,
                                 IgniteSupplier<Iterable<javax.cache.Cache.Entry<K,V>>> entriesGen,
                                 IgniteBinaryOperator<A> comb,
                                 IgniteSupplier<A> zeroValSupp)

Distributed version of fold operation. This method also applicable to sparse zeroes.

Parameters:

cacheName - Cache name.

ignite - ignite

acc - Accumulator

supp - supplier

entriesGen - entries generator

comb - combiner

zeroValSupp - Zero value supplier.

Returns:

aggregated result

reduce

public static <K,V,A,W> A reduce(String cacheName,
                                 IgniteTriFunction<W,javax.cache.Cache.Entry<K,V>,A,A> acc,
                                 IgniteSupplier<W> supp,
                                 IgniteSupplier<Iterable<javax.cache.Cache.Entry<K,V>>> entriesGen,
                                 IgniteBinaryOperator<A> comb,
                                 IgniteSupplier<A> zeroValSupp)

Distributed version of fold operation.

Parameters:

cacheName - Cache name.

acc - Accumulator

supp - supplier

entriesGen - entries generator

comb - combiner

zeroValSupp - Zero value supplier

Returns:

aggregated result

bcast

public static void bcast(String cacheName,
                         Ignite ignite,
                         IgniteRunnable run)

Parameters:

cacheName - Cache name.

run - Runnable to broadcast to cache nodes for given cache name.

bcast

public static void bcast(String cacheName,
                         IgniteRunnable run)

Broadcast runnable to data nodes of given cache.

Parameters:

cacheName - Cache name.

run - Runnable.

bcast

public static <A> Collection<A> bcast(String cacheName,
                                      IgniteCallable<A> call)

Type Parameters:

A - Type returned by the callable.

Parameters:

cacheName - Cache name.

call - IgniteCallable to broadcast to cache nodes for given cache name.

bcast

public static <A> Collection<A> bcast(String cacheName,
                                      Ignite ignite,
                                      IgniteCallable<A> call)

Broadcast callable to data nodes of given cache.

Type Parameters:

A - Type of callable result.

Parameters:

cacheName - Cache name.

ignite - Ignite instance.

call - Callable to broadcast.

Returns:

Results of callable from each node.

sparseMapForVector

public static <K,V> void sparseMapForVector(UUID vectorUuid,
                                            IgniteDoubleFunction<V> mapper,
                                            String cacheName)

Parameters:

vectorUuid - Matrix UUID.

mapper - Mapping IgniteFunction.