com.tangosol.internal.net.topic.impl.paged.PagedTopicSubscriber Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of coherence Show documentation
Show all versions of coherence Show documentation
Oracle Coherence Community Edition
/*
* Copyright (c) 2000, 2020, Oracle and/or its affiliates.
*
* Licensed under the Universal Permissive License v 1.0 as shown at
* http://oss.oracle.com/licenses/upl.
*/
package com.tangosol.internal.net.topic.impl.paged;
import com.oracle.coherence.common.util.Options;
import com.tangosol.coherence.config.Config;
import com.tangosol.internal.net.DebouncedFlowControl;
import com.tangosol.internal.net.NamedCacheDeactivationListener;
import com.tangosol.internal.net.topic.impl.paged.agent.DestroySubscriptionProcessor;
import com.tangosol.internal.net.topic.impl.paged.agent.EnsureSubscriptionProcessor;
import com.tangosol.internal.net.topic.impl.paged.agent.HeadAdvancer;
import com.tangosol.internal.net.topic.impl.paged.agent.PollProcessor;
import com.tangosol.internal.net.topic.impl.paged.model.NotificationKey;
import com.tangosol.internal.net.topic.impl.paged.model.Page;
import com.tangosol.internal.net.topic.impl.paged.model.SubscriberGroupId;
import com.tangosol.internal.net.topic.impl.paged.model.Subscription;
import com.tangosol.internal.util.Primes;
import com.tangosol.io.Serializer;
import com.tangosol.net.CacheFactory;
import com.tangosol.net.FlowControl;
import com.tangosol.net.PartitionedService;
import com.tangosol.net.topic.Subscriber;
import com.tangosol.util.AbstractMapListener;
import com.tangosol.util.Base;
import com.tangosol.util.Binary;
import com.tangosol.util.CircularArrayList;
import com.tangosol.util.ExternalizableHelper;
import com.tangosol.util.Filter;
import com.tangosol.util.HashHelper;
import com.tangosol.util.InvocableMapHelper;
import com.tangosol.util.MapEvent;
import com.tangosol.util.MapListenerSupport;
import com.tangosol.util.filter.InKeySetFilter;
import java.util.ArrayList;
import java.util.BitSet;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Objects;
import java.util.Queue;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Function;
/**
* A subscriber of values from a paged topic.
*
* @author jk/mf 2015.06.15
* @since Coherence 14.1.1
*/
public class PagedTopicSubscriber
implements Subscriber, AutoCloseable,
MapListenerSupport.SynchronousListener
{
// ----- constructors ---------------------------------------------------
/**
* Create a {@link PagedTopicSubscriber}.
*
* @param pagedTopicCaches the {@link PagedTopicCaches} managing the underlying topic data
* @param options the {@link Option}s controlling this {@link PagedTopicSubscriber}
*/
protected PagedTopicSubscriber(PagedTopicCaches pagedTopicCaches, Option... options)
{
Options optionsMap = Options.from(Subscriber.Option.class, options);
Name nameOption = optionsMap.get(Name.class, null);
String sName = nameOption == null ? null : nameOption.getName();
m_listenerDeactivation = new DeactivationListener();
m_listenerGroupDeactivation = new GroupDeactivationListener();
f_caches = Objects.requireNonNull(pagedTopicCaches, "The TopicCaches parameter cannot be null");
f_serializer = f_caches.getSerializer();
f_subscriberGroupId = sName == null
? SubscriberGroupId.anonymous()
: SubscriberGroupId.withName(sName);
registerDeactivationListener();
// TODO: error out on unprocessed (therefor unsupported) Options
// TODO: should there be an option to control how we behave with unsupported/unrecognized options, should this
// be an an option by option basis?
f_fCompleteOnEmpty = optionsMap.contains(CompleteOnEmpty.class);
f_nNotificationId = f_caches.newNotifierId(); // used even if we don't wait to avoid endless channel scanning
Filtered filtered = optionsMap.get(Filtered.class);
Filter filter = filtered == null ? null : filtered.getFilter();
Convert convert = optionsMap.get(Convert.class);
Function function = convert == null ? null : convert.getFunction();
// TODO: it would be good to limit backlog to a page size, but we don't know how many values this will be
// we could average out received value sizes over time and build this up, but making the DebouncedFlowControl
// thread-safe may be more of a cost then its' worth
long cBacklog = f_caches.getCacheService().getCluster().getDependencies().getPublisherCloggedCount();
f_backlog = new DebouncedFlowControl((cBacklog * 2) / 3, cBacklog);
try
{
int cParts = f_caches.getPartitionCount();
int cChannel = f_caches.getChannelCount();
f_setPolledChannels = new BitSet(cChannel);
f_setHitChannels = new BitSet(cChannel);
List listSubParts = new ArrayList<>(cParts);
for (int i = 0; i < cParts; ++i)
{
// Note: we ensure against channel 0 in each partition, and it will in turn initialize all channels
listSubParts.add(new Subscription.Key(i, /*nChannel*/ 0, f_subscriberGroupId));
}
// outside of any lock discover if pages are already pinned. Note that since we don't
// hold a lock, this is only useful if the group was already fully initialized (under lock) earlier.
// Otherwise there is no guarantee that there isn't gaps in our pinned pages.
// check results to verify if initialization has already completed
Collection colPages = sName == null
? null
: InvocableMapHelper.invokeAllAsync(
f_caches.Subscriptions, listSubParts, key -> pagedTopicCaches.getUnitOfOrder(key.getPartitionId()),
new EnsureSubscriptionProcessor(EnsureSubscriptionProcessor.PHASE_INQUIRE, null, filter, function))
.get().values();
long lPageBase = pagedTopicCaches.getBasePage();
long[] alHead = new long[cChannel];
if (colPages == null || colPages.contains(null))
{
// The subscription doesn't exist in at least some partitions, create it under lock. A lock is used only
// to protect against concurrent create/destroy/create resulting an gaps in the pinned pages. Specifically
// it would be safe for multiple subscribers to concurrently "create" the subscription, it is only unsafe
// if there is also a concurrent destroy as this could result in gaps in the pinned pages.
if (sName != null)
{
f_caches.Subscriptions.lock(f_subscriberGroupId, -1);
}
try
{
colPages = InvocableMapHelper.invokeAllAsync(f_caches.Subscriptions, listSubParts,
key -> pagedTopicCaches.getUnitOfOrder(key.getPartitionId()),
new EnsureSubscriptionProcessor(EnsureSubscriptionProcessor.PHASE_PIN, null, filter, function))
.get().values();
Configuration configuration = f_caches.getConfiguration();
// mapPages now reflects pinned pages
for (int nChannel = 0; nChannel < cChannel; ++nChannel)
{
final int finChan = nChannel;
if (configuration.isRetainConsumed())
{
// select lowest page in each channel as our channel heads
alHead[nChannel] = colPages.stream()
.mapToLong((alPage) -> Math.max(alPage[finChan], lPageBase))
.min()
.getAsLong();
}
else
{
// select highest page in each channel as our channel heads
alHead[nChannel] = colPages.stream()
.mapToLong((alPage) -> Math.max(alPage[finChan], lPageBase))
.max()
.getAsLong();
}
}
// finish the initialization by having subscription in all partitions advance to our selected heads
InvocableMapHelper.invokeAllAsync(f_caches.Subscriptions, listSubParts,
key -> pagedTopicCaches.getUnitOfOrder(key.getPartitionId()),
new EnsureSubscriptionProcessor(EnsureSubscriptionProcessor.PHASE_ADVANCE, alHead, filter, function))
.join();
}
finally
{
if (sName != null)
{
f_caches.Subscriptions.unlock(f_subscriberGroupId);
}
}
}
else
{
// all partitions were already initialized, min is our head
for (int nChannel = 0; nChannel < cChannel; ++nChannel)
{
final int finChan = nChannel;
alHead[nChannel] = colPages.stream().mapToLong((alResult) -> alResult[finChan])
.min().orElse(Page.NULL_PAGE);
}
}
Channel[] aChannel = f_aChannel = new Channel[cChannel];
for (int nChannel = 0; nChannel < cChannel; ++nChannel)
{
Channel channel = aChannel[nChannel] = new Channel();
channel.lHead = alHead[nChannel];
channel.nNext = -1; // unknown page position to start
channel.fEmpty = false; // even if we could infer emptiness here it is unsafe unless we've registered for events
// we don't just use (0,chan) as that would concentrate extra load on a single partitions when there are many groups
int nPart = Math.abs((HashHelper.hash(f_subscriberGroupId.hashCode(), nChannel) % cParts));
channel.subscriberPartitionSync = new Subscription.Key(nPart, nChannel, f_subscriberGroupId);
}
// select a random prime step which is larger then the channel count. This will ensure that this subscriber
// visits all channels before revisiting any while also "randomizing" the the visitation order w.r.t other
// members of the same subscription to minimize the chances of contention.
f_nChannelStep = Primes.random(cChannel);
m_nChannel = Base.mod(f_nChannelStep, cChannel);
// register a subscriber listener in each partition, we must be completely setup before doing this
// as the callbacks assume we're fully initialized
f_caches.Notifications.addMapListener(this, new InKeySetFilter<>(/*filter*/ null,
f_caches.getPartitionNotifierSet(f_nNotificationId)), /*fLite*/ false);
}
catch (Exception e)
{
throw Base.ensureRuntimeException(e);
}
// Note: post construction this implementation must be fully async
}
// ----- Subscriber methods ---------------------------------------------
@Override
public CompletableFuture> receive()
{
CompletableFuture> future = new CompletableFuture<>();
f_queueReceiveOrders.add(future);
if (m_fClosed) // testing after adding to above queue ensures that concurrent close won't miss canceling a future
{
future.cancel(true); // only in case it made it into the set returned from flush
f_queueReceiveOrders.remove(future); // avoid memory build up in case of repeated post-close calls
ensureActive(); // throw
}
else
{
// only after ensuring state do we increment the count, thus we ensure that a value will not be requested
// on our behalf if we've cancelled above
f_backlog.incrementBacklog();
scheduleReceives();
}
return future;
}
@Override
public FlowControl getFlowControl()
{
return f_backlog;
}
// ----- MapListener methods --------------------------------------------
@Override
public void entryInserted(MapEvent evt)
{
// TODO: filter out this event type
}
@Override
public void entryUpdated(MapEvent evt)
{
// TODO: filter out this event type
}
@Override
public void entryDeleted(MapEvent evt)
{
++m_cNotify;
for (int nChannel : evt.getOldValue())
{
f_aChannel[nChannel].fEmpty = false;
}
if (f_lockRemoveSubmit.compareAndSet(LOCK_WAIT, LOCK_OPEN))
{
switchChannel();
scheduleReceives();
}
// else; we weren't waiting so things are already scheduled
}
@Override
public void onClose(Runnable action)
{
f_listOnCloseActions.add(action);
}
@Override
public boolean isActive()
{
return !m_fClosed;
}
// ----- Closeable methods ----------------------------------------------
@Override
public void close()
{
closeInternal(false);
}
// ----- Object methods -------------------------------------------------
@Override
public String toString()
{
if (m_fClosed)
{
return getClass().getSimpleName() + "(inactive)";
}
long cPollsNow = m_cPolls;
long cValuesNow = m_cValues;
long cMissesNow = m_cMisses;
long cCollNow = m_cMissCollisions;
long cWaitNow = m_cWait;
long cNotifyNow = m_cNotify;
long cPoll = cPollsNow - m_cPollsLast;
long cValues = cValuesNow - m_cValuesLast;
long cMisses = cMissesNow - m_cMissesLast;
long cColl = cCollNow - m_cMissCollisionsLast;
long cWait = cWaitNow - m_cWaitsLast;
long cNotify = cNotifyNow - m_cNotifyLast;
m_cPollsLast = cPollsNow;
m_cValuesLast = cValuesNow;
m_cMissesLast = cMissesNow;
m_cMissCollisionsLast = cCollNow;
m_cWaitsLast = cWaitNow;
m_cNotifyLast = cNotifyNow;
int cChannelsPolled = f_setPolledChannels.cardinality();
int cChannelsHit = f_setHitChannels.cardinality();
String sChannlesHit = f_setHitChannels.toString();
f_setPolledChannels.clear();
f_setHitChannels.clear();
return getClass().getSimpleName() + "(" + "topic=" + f_caches.getTopicName() +
", group=" + f_subscriberGroupId +
", closed=" + m_fClosed +
", backlog=" + f_backlog +
", channels=" + sChannlesHit + cChannelsHit + "/" + cChannelsPolled +
", batchSize=" + (cValues / (Math.max(1, cPoll - cMisses))) +
", hitRate=" + ((cPoll - cMisses) * 100 / Math.max(1, cPoll)) + "%" +
", colRate=" + (cColl * 100 / Math.max(1, cPoll)) + "%" +
", waitNotifyRate=" + (cWait * 100 / Math.max(1, cPoll)) + "/" + (cNotify * 100 / Math.max(1, cPoll)) + "%" +
')';
}
// ----- helper methods -------------------------------------------------
/**
* Ensure that the subscriber is active.
*
* @throws IllegalStateException if not active
*/
private void ensureActive()
{
if (!isActive())
{
throw new IllegalStateException("The subscriber is not active");
}
}
/**
* Compare-and-increment the remote head pointer.
*
* @param lHeadAssumed the assumed old value, increment will only occur if the actual head matches this value
*/
protected void scheduleHeadIncrement(Channel channel, long lHeadAssumed)
{
if (!m_fClosed)
{
// update the globally visible head page
InvocableMapHelper.invokeAsync(f_caches.Subscriptions, channel.subscriberPartitionSync,
f_caches.getUnitOfOrder(channel.subscriberPartitionSync.getPartitionId()),
new HeadAdvancer(lHeadAssumed + 1),
(lPriorHeadRemote, e2) ->
{
if (lPriorHeadRemote < lHeadAssumed + 1)
{
// our CAS succeeded, we'd already updated our local head before attempting it
// but we do get to clear any contention since the former winner's CAS will fail
channel.fContended = false;
// we'll allow the channel to be removed from the contended channel list naturally during
// the next nextChannel call
}
else
{
// our CAS failed; i.e. the remote head was already at or beyond where we tried to set it.
// comparing against the prior value allows us to know if we won or lost the CAS which
// we can use to coordinate contention such that only the losers backoff
if (lHeadAssumed != Page.NULL_PAGE)
{
// we thought we knew what page we were on, but we were wrong, thus someone
// else had incremented it, this is a collision. Backoff and allow them
// temporary exclusive access, they'll do the same for the channels we
// increment
if (!channel.fContended)
{
channel.fContended = true;
f_listChannelsContended.add(channel);
}
m_cHitsSinceLastCollision = 0;
}
// else; we knew we were contended, don't doubly backoff
if (lPriorHeadRemote > channel.lHead)
{
// only update if we haven't locally moved ahead; yes it is possible that we lost the
// CAS but have already advanced our head simply through brute force polling
channel.lHead = lPriorHeadRemote;
channel.nNext = -1; // unknown page position
}
}
});
}
}
/**
* Attempt to fulfill any queue'd orders.
*/
protected void scheduleReceives()
{
for (long cOrders = f_backlog.getBacklog();
cOrders > 0 && !m_fClosed &&
f_lockRemoveSubmit.get() == LOCK_OPEN && f_lockRemoveSubmit.compareAndSet(LOCK_OPEN, LOCK_POLL); )
{
Collection colPrefetched = m_listValuesPrefetched;
if (colPrefetched != null) // uncommon
{
// we already have values we can hand out immediately
for (Iterator iter = colPrefetched.iterator();
iter.hasNext() && consumeValue(iter.next());
iter.remove())
{}
if (colPrefetched.isEmpty())
{
m_listValuesPrefetched = null;
}
}
// update the value now that we hold the lock, it could have increased by other threads, and more
// importantly it could have decreased as we serviced pre-fetched
cOrders = f_backlog.getBacklog();
if (cOrders == 0)
{
// no need to request zero items
f_lockRemoveSubmit.set(LOCK_OPEN);
// now that we've unlocked we need to ensure that there wasn't a concurrent add which
// we would be responsible for fetching; re-lock and schedule if necessary
}
else // common
{
int nChannel = m_nChannel;
Channel channel = f_aChannel[nChannel];
long lHead = channel.lHead;
int nPart = ((PartitionedService) f_caches.Subscriptions.getCacheService())
.getKeyPartitioningStrategy().getKeyPartition(new Page.Key(nChannel, lHead));
InvocableMapHelper.invokeAsync(f_caches.Subscriptions,
new Subscription.Key(nPart, nChannel, f_subscriberGroupId), f_caches.getUnitOfOrder(nPart),
new PollProcessor(lHead, (int) cOrders, f_nNotificationId),
(result, e) -> onReceiveResult(channel, lHead, result, e));
// at this point we technically don't hold the lock anymore it is held by the EP which oddly may have
// completed by now. Most likely we won't execute the loop an additional time as it would be quite
// unusual (though possible) for the EP to have completed by now. It would be allowable to just return
// here but that is just so ugly
}
}
// else; already scheduled or nothing to schedule
}
/**
* Use the specified value to complete one of this subscriber's outstanding futures.
*
* @param binValue the value to consume
*
* @return true iff the value was consumed
*/
protected boolean consumeValue(Binary binValue)
{
CompletableFuture> futureNext;
while ((futureNext = f_queueReceiveOrders.poll()) != null)
{
f_backlog.decrementBacklog();
if (futureNext.complete(new RemovedElement(binValue)))
{
return true;
}
}
return false;
}
/**
* Find the next non-empty channel.
*
* @param nChannel the current channel
*
* @return the next non-empty channel, or nChannel if all are empty
*/
protected int nextChannel(int nChannel)
{
int cChannels = f_aChannel.length;
int nChannelStart = nChannel;
boolean fContention = !f_listChannelsContended.isEmpty();
while (fContention)
{
// it's possible that a channel was marked as empty after already having been identified
// as contended. i.e. we issue a poll on that channel while we are concurrently querying
// the head. The increment fails and the channel is marked as contended, and then we get
// back an empty result set and
Channel chan = f_listChannelsContended.get(0);
if (chan.fEmpty || !chan.fContended)
{
f_listChannelsContended.remove(0);
chan.fContended = false;
fContention = !f_listChannelsContended.isEmpty();
}
else
{
break;
}
}
Channel chanContended = m_cHitsSinceLastCollision > COLLISION_BACKOFF_COUNT && fContention
? f_listChannelsContended.get(0) : null;
// if chanContended is non-null then we'll return it unless there are uncontended channels earlier in the
// search order in which case the contendeds have to wait their turn. This ensures we check each channel
// at most once per pass over all other channels unless the channel is contended, in which case we don't
// select it until we've had a sufficient number of hits
do
{
// long mod is used as nChannel + step may cause overflow and while an int mod would
// yield a safe array index it wouldn't ensure that we'd eventually visit all channels
nChannel = (int) Base.mod(nChannel + (long) f_nChannelStep, cChannels);
Channel channel = f_aChannel[nChannel];
if (!channel.fEmpty && (!channel.fContended || channel == chanContended))
{
return nChannel;
}
}
while (nChannel != nChannelStart);
// we didn't find any non-empty uncontended channels and ended up back at our start channel.
// the start channel wasn't selected in the loop thus it is either empty or contended.
// we know that the first element if any in f_listChannelsContended is non-empty and thus
// if if exists it is our first choice.
return fContention
? f_listChannelsContended.get(0).subscriberPartitionSync.getChannelId()
: nChannelStart;
}
/**
* Switch to the next available channel.
*
* @return true if a potentially non-empty channel has been found false iff all channels are known to be empty
*/
protected boolean switchChannel()
{
int nChannelStart = m_nChannel;
int nChannel = m_nChannel = nextChannel(nChannelStart);
Channel channel = f_aChannel[nChannel];
if (channel.fEmpty)
{
return false;
}
else if (channel.fContended)
{
channel.fContended = false; // clear the contention now that we've selected it
f_listChannelsContended.remove(0);
}
int nChannelNext = nextChannel(nChannel);
if (nChannelNext != nChannel && nChannelNext != nChannelStart)
{
Channel channelNext = f_aChannel[nChannelNext];
if (channelNext.fContended)
{
// do read-ahead of the next channel head so that when we finish
// with the new one we are likely at the proper position for the next
scheduleHeadIncrement(channelNext, Page.NULL_PAGE);
}
}
return true;
}
/**
* Handle the result of an async receive.
*
* @param channel the associated channel
* @param lPageId lTail the page the receive targeted
* @param result the result
* @param e and exception
*/
protected void onReceiveResult(Channel channel, long lPageId, PollProcessor.Result result, Throwable e)
{
if (e == null)
{
int nChannel = channel.subscriberPartitionSync.getChannelId();
List listValues = result.getElements();
int cReceived = listValues.size();
int cRemaining = result.getRemainingElementCount();
int nNext = result.getNextIndex();
f_setPolledChannels.set(nChannel);
++m_cPolls;
if (cReceived == 0)
{
++m_cMisses;
if (channel.nNext != nNext && channel.nNext != -1) // collision
{
++m_cMissCollisions;
m_cHitsSinceLastCollision = 0;
// don't backoff here, as it is possible all subscribers could end up backing off and
// the channel would be temporarily abandoned. We only backoff as part of trying to increment the
// page as that is a CAS and for someone to fail, someone else must have succeeded.
}
// else; spurious notify
}
else
{
f_setHitChannels.set(nChannel);
++m_cHitsSinceLastCollision;
m_cValues += cReceived;
// fulfill requests
for (Iterator iter = listValues.iterator();
iter.hasNext() && consumeValue(iter.next());
iter.remove())
{}
if (!listValues.isEmpty())
{
// hold onto remaining values; these values will be drained before any further values are fetched
// see scheduleReceives
m_listValuesPrefetched = listValues;
}
}
channel.nNext = nNext;
if (cRemaining == PollProcessor.Result.EXHAUSTED)
{
// we know the page is exhausted, so the new head is at least one higher
if (lPageId >= channel.lHead && lPageId != Page.NULL_PAGE)
{
channel.lHead = lPageId + 1;
channel.nNext = 0;
}
// we'll concurrently increment the durable head pointer and then update our pointer accordingly
scheduleHeadIncrement(channel, lPageId);
// switch to a new channel since we've exhausted this page
switchChannel();
}
else if (cRemaining == 0)
{
channel.fEmpty = true;
if (!switchChannel())
{
// we've run out of channels to poll from
if (f_fCompleteOnEmpty)
{
// complete everything with null, we know all channels are currently empty
CompletableFuture> next;
while ((next = f_queueReceiveOrders.poll()) != null)
{
f_backlog.decrementBacklog();
next.complete(null);
}
}
else
{
// wait for non-empty;
// Note: automatically registered for notification as part of returning an empty result set
++m_cWait;
f_lockRemoveSubmit.set(LOCK_WAIT);
}
}
}
else if (cRemaining == PollProcessor.Result.UNKNOWN_SUBSCRIBER)
{
// The subscriber was unknown, probably due to being destroyed whilst
// the poll was in progress.
closeInternal(true);
}
if (m_fClosed)
{
// cancelling here ensures we can't loose data as there are no requests on the wire
f_queueReceiveOrders.forEach(future -> future.cancel(true));
f_lockRemoveSubmit.set(LOCK_CLOSED);
}
else
{
// we'll concurrently attempt to remove more
// Note: the unlock must be done last, specifically we don't want more removes scheduled
// until after we've updated m_alHead (if it will be done)
if (f_lockRemoveSubmit.compareAndSet(LOCK_POLL, LOCK_OPEN))
{
scheduleReceives();
}
// else; we're in LOCK_WAIT state
}
}
else // remove failed; this is fairly catastrophic
{
// TODO: figure out error handling
// fail all currently (and even concurrently) scheduled removes
CompletableFuture> next;
while ((next = f_queueReceiveOrders.poll()) != null)
{
f_backlog.decrementBacklog();
next.completeExceptionally(e);
}
f_lockRemoveSubmit.set(LOCK_OPEN);
scheduleReceives();
}
}
/**
* Destroy subscriber group.
*
* @param pagedTopicCaches the associated caches
* @param subscriberGroupId the group to destroy
*/
static void destroy(PagedTopicCaches pagedTopicCaches, SubscriberGroupId subscriberGroupId)
{
int cParts = ((PartitionedService) pagedTopicCaches.Subscriptions.getCacheService()).getPartitionCount();
List listSubParts = new ArrayList<>(cParts);
for (int i = 0; i < cParts; ++i)
{
// channel 0 will propagate the operation to all other channels
listSubParts.add(new Subscription.Key(i, /*nChannel*/ 0, subscriberGroupId));
}
// see note in TopicSubscriber constructor regarding the need for locking
boolean fNamed = subscriberGroupId.getMemberTimestamp() == 0;
if (fNamed)
{
pagedTopicCaches.Subscriptions.lock(subscriberGroupId, -1);
}
try
{
InvocableMapHelper.invokeAllAsync(pagedTopicCaches.Subscriptions, listSubParts,
(key) -> pagedTopicCaches.getUnitOfOrder(key.getPartitionId()),
DestroySubscriptionProcessor.INSTANCE)
.join();
}
finally
{
if (fNamed)
{
pagedTopicCaches.Subscriptions.unlock(subscriberGroupId);
}
}
}
/**
* Close and clean-up this subscriber.
*
* @param fDestroyed {@code true} if this call is in response to the caches
* being destroyed/released and hence just clean up local
* state
*/
private void closeInternal(boolean fDestroyed)
{
synchronized (this)
{
if (!m_fClosed)
{
m_fClosed = true; // accept no new requests, and cause all pending ops to complete ASAP (see onReceiveResult)
try
{
if (!fDestroyed)
{
// caches have not been destroyed so we're just closing this subscriber
unregisterDeactivationListener();
// un-register the subscriber listener in each partition
f_caches.Notifications.removeMapListener(this, new InKeySetFilter<>(/*filter*/ null, f_caches.getPartitionNotifierSet(f_nNotificationId)));
}
if (fDestroyed || f_lockRemoveSubmit.compareAndSet(LOCK_OPEN, LOCK_CLOSED) ||
f_lockRemoveSubmit.compareAndSet(LOCK_WAIT, LOCK_CLOSED))
{
// we're being destroyed or no EPs outstanding; just cancel everything which is queued
f_queueReceiveOrders.forEach(future -> future.cancel(true));
}
else
{
// wait for EP result which will fulfill what it can and cancel the rest
CompletableFuture.allOf(f_queueReceiveOrders.toArray(new CompletableFuture[0])).handle((v, t) -> null).join();
}
if (!fDestroyed && f_subscriberGroupId.getMemberTimestamp() != 0)
{
// this subscriber is anonymous and thus non-durable and must be destroyed upon close
// Note: if close isn't the cluster will eventually destroy this subscriber once it
// identifies the associated member has left the cluster.
// TODO: should we also do it via a finalizer or similar to avoid leaks if app code forgets
// to call close?
destroy(f_caches, f_subscriberGroupId);
}
}
finally
{
f_listOnCloseActions.forEach(action ->
{
try
{
action.run();
}
catch (Throwable t)
{
CacheFactory.log(t);
}
});
}
}
}
}
/**
* Instantiate and register a DeactivationListener with the topic subscriptions cache.
*/
@SuppressWarnings("unchecked")
protected void registerDeactivationListener()
{
try
{
GroupDeactivationListener listenerGroup = m_listenerGroupDeactivation;
if (listenerGroup != null)
{
f_caches.Subscriptions.addMapListener(listenerGroup, new Subscription.Key(0, 0, f_subscriberGroupId), true);
}
NamedCacheDeactivationListener listener = m_listenerDeactivation;
if (listener != null)
{
f_caches.Subscriptions.addMapListener(listener);
}
}
catch (RuntimeException e) {}
}
/**
* Unregister cache deactivation listener.
*/
@SuppressWarnings("unchecked")
protected void unregisterDeactivationListener()
{
try
{
GroupDeactivationListener listenerGroup = m_listenerGroupDeactivation;
if (listenerGroup != null)
{
f_caches.Subscriptions.removeMapListener(listenerGroup, new Subscription.Key(0, 0, f_subscriberGroupId));
}
NamedCacheDeactivationListener listener = m_listenerDeactivation;
if (listener != null)
{
f_caches.Subscriptions.removeMapListener(listener);
}
}
catch (RuntimeException e) {}
}
// ----- inner class: RemovedElement ------------------------------------
/**
* RemovedElement holds an value removed from the topic.
*/
private class RemovedElement
implements Element
{
RemovedElement(Binary binValue)
{
m_binValue = binValue;
}
@Override
public V getValue()
{
Binary binValue = m_binValue;
V value = m_value;
if (binValue != null)
{
synchronized (this)
{
binValue = m_binValue;
if (binValue == null)
{
value = m_value;
}
else
{
m_value = value = ExternalizableHelper.fromBinary(binValue, f_serializer);
m_binValue = null;
}
}
}
return value;
}
// ----- data members -----------------------------------------------
/**
* The serialized value, null once deserialized.
*/
private Binary m_binValue;
/**
* The removed value, null until deseralized.
*/
private volatile V m_value;
}
/**
* Channel is a data structure which represents the state of a channel as known
* by this subscriber.
*/
protected static class Channel
{
/**
* The current head page for this subscriber, this value may safely be behind (but not ahead) of the actual head.
*
* volatile as it is possible it gets concurrently updated by multiple threads if the futures get completed
* on IO threads. We don't both going with a full blow AtmoicLong as either value is suitable and worst case
* we update to an older value and this would be harmless and just get corrected on the next attempt.
*/
volatile long lHead;
/**
* The index of the next item in the page, or -1 for unknown
*/
int nNext = -1;
/**
* True if the channel has been found to be empty. Once identified as empty we don't need to poll form it again
* until we receive an event indicating that it has seen a new insertion.
*/
boolean fEmpty;
/**
* The key which holds the channels head for this group.
*/
Subscription.Key subscriberPartitionSync;
/**
* True if contention has been detected on this channel.
*/
boolean fContended;
public String toString()
{
return "Channel=" + subscriberPartitionSync.getChannelId() +
", empty=" + fEmpty +
", head=" + lHead +
", next=" + nNext +
", contended=" + fContended;
}
}
// ----- inner class: DeactivationListener ------------------------------
/**
* A {@link NamedCacheDeactivationListener} to detect the subscribed topic
* being destroyed.
*/
protected class DeactivationListener
extends AbstractMapListener
implements NamedCacheDeactivationListener
{
@Override
public void entryDeleted(MapEvent evt)
{
// destroy/disconnect event
CacheFactory.log("Detected destroy of topic "
+ f_caches.getTopicName() + ", closing subscriber "
+ PagedTopicSubscriber.this, CacheFactory.LOG_QUIET);
closeInternal(true);
}
}
// ----- inner class: GroupDeactivationListener -------------------------
/**
* A {@link AbstractMapListener} to detect the removal of the subscriber group
* that the subscriber is subscribed to.
*/
protected class GroupDeactivationListener
extends AbstractMapListener
{
@Override
public void entryDeleted(MapEvent evt)
{
// destroy subscriber group
CacheFactory.log("Detected removal of subscriber group "
+ f_subscriberGroupId.getGroupName() + ", closing subscriber "
+ PagedTopicSubscriber.this, CacheFactory.LOG_QUIET);
closeInternal(true);
}
}
// ----- constants ------------------------------------------------------
/**
* Value of an available lock.
*/
protected static final int LOCK_OPEN = 0;
/**
* Value of a lock which is polling the topic.
*/
protected static final int LOCK_POLL = 1;
/**
* Value of a lock which is waiting on the topic.
*/
protected static final int LOCK_WAIT = 2;
/**
* Value of a lock when subscriber is closing/closed.
*/
protected static final int LOCK_CLOSED = 3;
/**
* The number of hits before we'll retry a previously contended channel.
*/
protected static final int COLLISION_BACKOFF_COUNT = Integer.parseInt(Config.getProperty(
"coherence.pagedTopic.collisionBackoff", "100"));
// ----- data members ---------------------------------------------------
/**
* The {@link PagedTopicCaches} instance managing the caches for the topic
* being consumed.
*/
protected final PagedTopicCaches f_caches;
/**
* The cache's serializer.
*/
protected final Serializer f_serializer;
/**
* The identifier for this {@link PagedTopicSubscriber}.
*/
protected final SubscriberGroupId f_subscriberGroupId;
/**
* This subscriber's notification id.
*/
protected final int f_nNotificationId;
/**
* True if configured to complete when empty
*/
protected final boolean f_fCompleteOnEmpty;
/**
* True iff the subscriber has been closed.
*/
protected volatile boolean m_fClosed;
/**
* Optional list of prefetched values which can be used to fulfil future receive requests.
*/
protected Collection m_listValuesPrefetched;
/**
* Queue of pending receive awaiting values.
*/
protected final Queue>> f_queueReceiveOrders = new ConcurrentLinkedQueue<>();
/**
* Subscriber flow control object.
*/
protected final DebouncedFlowControl f_backlog;
/**
* The submit lock for remove operations, legal values are from LOCK_* above.
*/
protected final AtomicInteger f_lockRemoveSubmit = new AtomicInteger();
/**
* The state for the channels.
*/
protected final Channel[] f_aChannel;
/**
* The current channel.
*/
protected int m_nChannel;
/**
* The amount to step between channel selection.
*/
protected final int f_nChannelStep;
/**
* The number of poll requests.
*/
protected long m_cPolls;
/**
* The last value of m_cPolls used within {@link #toString} stats.
*/
protected long m_cPollsLast;
/**
* The number of values received.
*/
protected long m_cValues;
/**
* The last value of m_cValues used within {@link #toString} stats.
*/
protected long m_cValuesLast;
/**
* The number of times this subscriber has waited.
*/
protected long m_cWait;
/**
* The last value of m_cWait used within {@link #toString} stats.
*/
protected long m_cWaitsLast;
/**
* The number of misses;
*/
protected long m_cMisses;
/**
* The last value of m_cMisses used within {@link #toString} stats.
*/
protected long m_cMissesLast;
/**
* The number of times a miss was attributable to a collision
*/
protected long m_cMissCollisions;
/**
* The last value of m_cMissCollisions used within {@link #toString} stats.
*/
protected long m_cMissCollisionsLast;
/**
* The number of times this subscriber has been notified.
*/
protected long m_cNotify;
/**
* The last value of m_cNotify used within {@link #toString} stats.
*/
protected long m_cNotifyLast;
/**
* The number of hits since our last miss.
*/
protected int m_cHitsSinceLastCollision;
/**
* List of contended channels, ordered such that those checked longest ago are at the front of the list
*/
protected final List f_listChannelsContended = new CircularArrayList();
/**
* BitSet of polled channels since last toString call.
*/
protected final BitSet f_setPolledChannels;
/**
* BitSet of channels which hit since last toString call.
*/
protected final BitSet f_setHitChannels;
/**
* The NamedCache deactivation listener.
*/
protected NamedCacheDeactivationListener m_listenerDeactivation;
/**
* The NamedCache deactivation listener.
*/
protected GroupDeactivationListener m_listenerGroupDeactivation;
/**
* A {@link List} of actions to run when this publisher closes.
*/
private final List f_listOnCloseActions = new ArrayList<>();
}