Open
Conversation
* Wait for all order processing to finish before ending process
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
1 participant
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Hey Jeremy,
Hopefully your trip back to the frozen north was easy and snag free.
Per our quick discussion @ NFJS ATL, I added support for Akka actors in addition to the single/multi/scala ones. From what I have been reading (e.g. check out http://www.slideshare.net/shinolajla/taxonomy-ofscala), the Akka implementation of actors will replace the Scala version. Both Akka and Scala (and Play etc) are Typesafe - so it's not too far of a stretch.
I also changed the rules a bit in that all of the orders must be processed for a batch to be considered "complete" - sort of a standard fork-join approach. This significantly changes the relative performance of these on my quad-core Ubuntu VM. I still see Multi lead, but the lead over Akka is tiny, and the lead over Scala actors is small. Of course single-threaded is slow. IMO this makes the benchmark better, and less of a question of who initializes faster/better/etc.
For Example, running
cogito.online.processing.BatchServicesTest:It really didn't sound right to me that there was such a big lead of an executor over an actor library. I know Akka fairly well, there's probably some work that can be done with the Scala actor approach to make it more optimal and representative.
Finally I updated the scala libraries to something more current (2.9.2), in part because that's consistent with the current tools (Scala-IDE on Eclipse). The scala tools repo has moved, and I would expect that to cause issues, maybe because i'm not running maven command line, it's not an issue yet. Anyways that was to get off the ground, I was having trouble getting it working without those changes.
Anyways, take a look - let me know what you think. I'll probably keep hacking on it, but wanted to give you a preview of where I was going. I'd certainly like to DRY it out a bit I'd be happy if you were able to use it as part of future resource-oriented concurrency talks, but even if it ends up being just something else to consider I think it's time well spent.
Thanks,
Brian