* The problem was that akka://all-systems/StandardOutLogger ref was
passed during system shutdown
* Add special serialization of StandardOutLogger, and Nobody
Note: This is NOT aimed to provide an micro-benchmarking solution.
The goal is to provide data for broad trend analysis. For techniques
that fight the inliner and other specialised techniques, refer to JMH.
+ custom console and graphite reporters
- had to be custom because it's not possible to add custom metric
types to the existing reporters
+ initial hdr.Histogram histogram() provider, see
http://latencyutils.github.io/LatencyUtils/
+ Not using timers provided by Metrics, instead use the above histogram
+ Added average Actor size measurement
+ Measuring the "blocking time" when an actor is created, before we fire
of the async part of this process; Measures in loop and will fluctuate
a lot. Times are in `us` -- System.nanoTime should provide good enough
resolution.
+ Measuring total actor creation time by using
`KnownOpsInTimespanTimer`, which given a known number of ops, in a
large amount of time, roughtly estimates time per one operation.
// Yes, we are aware of the possibility of GC pauses and other horrors
+ All classes are `private[akka]`, we should not encourage people to use
this yet
+ Counters use Java 8's `LongAdder`, which is metric's private;
The new trend in Java land will be copy paste-ing this class ;)
+ Metrics are logged to Graphite, so we can long-term analyse these
+ Reporters are configurable using typesafe-config
! I'm not very happy about how I work around Metrics not being too open
for adding additional custom metrics. Seems like a hack at places.
I will consider removing the Metrics dependency all together.
numbers
Example output:
```
-- KnownOpsInTimespanTimer-------------------------------------------
actor-creation.total.creating-100000-actors.Props|new-EmptyArgsActor|…||-same
ops = 100000
time = 1.969 s
ops/s = 50782.22
avg = 19.69 μs
-- AveragingGauge---------------------------------------------------
actor-creation.Props|new-EmptyArgsActor|…||-same.avg-mem-per-actor
avg = 439.67
```
These are visible on the grafana dashboard,
in order to be able to see on which commit
stats have been recorded.
It's enabled via: `-Dakka.sbt.graphite=true`
Resolves#15103
Instead of isTerminated we now use death watch on subscribers.
! Breaking change - ActorClassification based event buses now require
and actor system. Previously no actors were involved, but now someone
has to `watch` the subscribers. The unsubscriber is an system actor,
and won't be stopped automagically if a bus stops to be used (hard to
determine what "stops being used" is)
* Replaced isTerminated checks with watching actors
* backing structure for ActorClassification swaped from
ConcurrentHashMap to immutable.Map with CAS operations on it. This is
required to avoid races and guarantee register/unregister ordering
(messages sent with proper sequence numbers) to the unsubscriber.
Performance tested it and still above 1.3million subscribe+unsubscribe
ops per second (mac i7, retina), where as the CHM version was
4 million - but that one could only work in the presence of
itTerminated - so we pay the price here for removing it.
* `ActorClassification` starts the unsubscriber instance by itself,
the unsubscriber is an system actor, and can be stopped via
`ActorClassification#shutdown`
* Will unregister from unsubscriber, when no more subscriptions for
given subscriber are left in this bus.
* Added missing "Java API: " for some types
* Updated docs to point out the automatic subscriber purging (on terminated)
* Replace stash with internal bufferi, j.u.LinkedList
* Replace FSM with become
* Adaptive backoff, important to backoff, but not for too long,
depends on environment and use case
* Prioritize heartbeat messages from remote watcher and cluster
failure detector
* Use payload messages as heartbeats for transport failure detector,
change transport failure detector to be based on absolute timeout,
see ticket #13989 and #13742
* Log remote disassociate from transport failure detector,
see ticket #13985
* Add benchmark sample in akka-sample-remote-scala
* Moved to removing actors proactively when they are terminated instead of
checking `isTerminated` during publish.
* Subscribers which have registered before initializing the unsubscriber
will be aggregated in a Seq until one is registered and then it will
take responsibility of unregistering them on termination.
* Initialization of the unsubscriber can only be run once - attempting
to initialize the event stream with another unsubscriber will fail,
and init will return false.
* Assumed having an init (mutable) method on the `EventBus` is fine, as
it has such methods already and @patriknw's comment in the task for
this.
* since we must check if the subscriber has any subscribed channels left
we had to expose this detail from SubchannelClassification via
`hasSubscriptions`. Increases cost of ubsubscribe(actor, channel) a bit.
* Evacuated the expensive `hasSubscription` call out of eventstream's `unsubscribe` call, and instead making the Unsubscriber check this before it stops watching an actor. If in the mean time the same actor got subscribed, there will be a new Subscribe message emited - so we're good on that side. Also, if it would terminate before the unsubscriber gets the Register message it will call `watch(actor)` on a dead actor, which results in getting Terminated for it, thus we'll stop watching it from the Unsubscriber as expected.
Final squash and small cleanup. Please review again;
