Pinboard (jm)
https://pinboard.in/u:jm/public/
recent bookmarks from jmSWAR indexOf byte search2022-01-24T10:08:22+00:00
https://github.com/netty/netty/pull/10737/files
jmsimd swar indexof bytebuffer java optimization performance search netty hackshttps://pinboard.in/https://pinboard.in/u:jm/b:b1bb44f3ef08/ServiceTalk2019-11-06T14:00:14+00:00
https://github.com/apple/servicetalk/
jma JVM network application framework with APIs tailored to specific protocols (e.g. HTTP/1.x, HTTP/2.x, etc…) and supports multiple programming paradigms.
It is built on Netty and is designed to provide most of the performance/scalability benefits of Netty for common networking protocols used in service to service communication. ServiceTalk provides server support and "smart client" like features such as client-side load balancing and service discovery integration.
Open source from Apple.]]>apple servicetalk netty libraries java jvm coding http asynchttps://pinboard.in/https://pinboard.in/u:jm/b:d97f22fd741a/Moving From Apache Thrift to gRPC: A Perspective From Alluxio2019-06-27T09:21:18+00:00
https://www.alluxio.io/blog/moving-from-apache-thrift-to-grpc-a-perspective-from-alluxio/
jmThrift served well as a fast and reliable RPC framework powering the metadata operations in Alluxio 1.x. Its limitation in handling streamed data has led us to a journey in search of better alternatives. gRPC provides some nice features that help us in building a simpler, more unified API layer. In this post, we discussed some lessons learned to move from Thrift to gRPC, including performance tuning tips that helped us achieve comparable performance for both one-off RPC calls as well as data streams. We hope this helps if you are looking at gRPC as an option for building high-performance services. Check out our blog for more articles on how we build Alluxio.
]]>thrift alluxio java grpc protocols coding nettyhttps://pinboard.in/https://pinboard.in/u:jm/b:5b7ff8c205dc/Java's ByteBuffer native memory "leak"2018-11-19T11:30:30+00:00
http://www.evanjones.ca/java-bytebuffer-leak.html
jmThe Java NIO APIs use ByteBuffers as the source and destination of I/O calls, and come in two flavours. Heap ByteBuffers wrap a byte[] array, allocated in the garbage collected Java heap. Direct ByteBuffers wrap memory allocated outside the Java heap using malloc. Only "native" memory can be passed to operating system calls, so it won't be moved by the garbage collector. This means that when you use a heap ByteBuffer for I/O, it is copied into a temporary direct ByteBuffer. The JDK caches one temporary buffer per thread, without any memory limits. As a result, if you call I/O methods with large heap ByteBuffers from multiple threads, your process can use a huge amount of additional native memory, which looks like a native memory leak. This can cause your process to unexpectedly run into memory limits and get killed.
]]>jvm performance java memory leaks bytebuffers netty threads coding bugshttps://pinboard.in/https://pinboard.in/u:jm/b:94c60cf2a090/Neutrino Software Load Balancer2016-02-18T14:49:52+00:00
http://neutrinoslb.github.io/
jmnetty scala ebay load-balancing load-balancers url http architecturehttps://pinboard.in/https://pinboard.in/u:jm/b:793be14e0ab4/Netty @Apple: Large Scale Deployment/Connectivity [video]2016-01-08T10:04:43+00:00
http://www.infoq.com/presentations/apple-netty
jmapple netty norman-maurer java jvm async talks presentationshttps://pinboard.in/https://pinboard.in/u:jm/b:09aa5e33f478/Introducing Netty-HTTP from Cask2015-12-03T12:52:22+00:00
http://blog.cask.co/2015/12/introducing-netty-http-from-cask/
jmnetty-http library solves [Netty usability issues] by using JAX-RS annotations to build a HTTP path routing layer on top of netty. In addition, the library implements a guava service to manage the HTTP service. netty-http allows users of the library to just focus on writing the business logic in HTTP handlers without having to worry about the complexities of path routing or learning netty pipeline internals to build the HTTP service.
We've written something very similar, although I didn't even bother supporting JAX-RS annotations -- just a simple code-level DSL.]]>jax-rs netty http cask java services codinghttps://pinboard.in/https://pinboard.in/u:jm/b:c5c91942c05c/How Netty is used at Layer2015-10-22T08:26:14+00:00
https://medium.com/@mubarak.seyed/netty-at-layer-powering-client-api-2a6ca3617d48#.91mjjdwh2
jmnetty http api-services coding java servershttps://pinboard.in/https://pinboard.in/u:jm/b:2a9e57061ee5/Netty's async DNS resolver2015-06-04T13:37:02+00:00
https://github.com/netty/netty/issues/3797#issuecomment-108356744
jmnetty dns async crawlers resolver benchmarks scanninghttps://pinboard.in/https://pinboard.in/u:jm/b:1a7b95094a3e/outbrain/gruffalo2015-04-10T13:34:17+00:00
https://github.com/outbrain/gruffalo
jman asynchronous Netty based graphite proxy. It protects Graphite from the herds of clients by minimizing context switches and interrupts; by batching and aggregating metrics. Gruffalo also allows you to replicate metrics between Graphite installations for DR scenarios, for example.
Gruffalo can easily handle a massive amount of traffic, and thus increase your metrics delivery system availability. At Outbrain, we currently handle over 1700 concurrent connections, and over 2M metrics per minute per instance.
]]>graphite backpressure metrics outbrain netty proxies gruffalo opshttps://pinboard.in/https://pinboard.in/u:jm/b:4beece5ba231/grpc.io2015-02-26T22:13:53+00:00
http://www.grpc.io/
jmhttp rpc http2 netty grpc google corba idl messaginghttps://pinboard.in/https://pinboard.in/u:jm/b:1a7c21fdee97/Spark 1.2 released2014-12-22T14:14:17+00:00
http://databricks.com/blog/2014/12/19/announcing-spark-1-2.html
jmSpark 1.2 includes several cross-cutting optimizations focused on performance for large scale workloads. Two new features Databricks developed for our world record petabyte sort with Spark are turned on by default in Spark 1.2. The first is a re-architected network transfer subsystem that exploits Netty 4’s zero-copy IO and off heap buffer management. The second is Spark’s sort based shuffle implementation, which we’ve now made the default after significant testing in Spark 1.1. Together, we’ve seen these features give as much as 5X performance improvement for workloads with very large shuffles.
]]>spark sorting hadoop map-reduce batch databricks apache nettyhttps://pinboard.in/https://pinboard.in/u:jm/b:6d93115441ec/Netty: Using as a generic library2014-11-14T14:25:46+00:00
http://netty.io/wiki/using-as-a-generic-library.html
jmmechanical-sympathy netty java bytebuffer object-pools data-structures hashed-wheel-timer algorithms timershttps://pinboard.in/https://pinboard.in/u:jm/b:695dece7885c/Jauter2014-10-22T13:25:34+00:00
https://github.com/xitrum-framework/jauter
jmThis Java library can route paths to targets and create paths from targets and params (reverse routing). This library is tiny, without additional dependencies, and is intended for use together with an HTTP server side library. If you want to use with Netty, see netty-router.
]]>java jauter scala request-routing http netty open-sourcehttps://pinboard.in/https://pinboard.in/u:jm/b:8ed24de49e45/Spark Breaks Previous Large-Scale Sort Record – Databricks2014-10-10T20:33:57+00:00
http://databricks.com/blog/2014/10/10/spark-breaks-previous-large-scale-sort-record.html
jmFirst and foremost, in Spark 1.1 we introduced a new shuffle implementation called sort-based shuffle (SPARK-2045). The previous Spark shuffle implementation was hash-based that required maintaining P (the number of reduce partitions) concurrent buffers in memory. In sort-based shuffle, at any given point only a single buffer is required. This has led to substantial memory overhead reduction during shuffle and can support workloads with hundreds of thousands of tasks in a single stage (our PB sort used 250,000 tasks).
Also, use of Timsort, an external shuffle service to offload from the JVM, Netty, and EC2 SR-IOV.]]>spark hadoop map-reduce batch parallel sr-iov benchmarks performance netty shuffle algorithms sort-based-shuffle timsorthttps://pinboard.in/https://pinboard.in/u:jm/b:c675a1f7b48b/Real time analytics with Netty, Storm, Kafka2014-08-09T11:32:45+00:00
http://www.slideshare.net/tantrieuf31/real-time-analytics-with-netty-storm-kafka
jmvia:trustinlee kafka storm netty architecture ad-tracking ads realtimehttps://pinboard.in/https://pinboard.in/u:jm/b:fe33709a254d/Moquette MQTT2014-05-29T15:35:02+00:00
https://projects.eclipse.org/proposals/moquette-mqtt
jma Java implementation of an MQTT 3.1 broker. Its code base is small. At its core, Moquette is an events processor; this lets the code base be simple, avoiding thread sharing issues. The Moquette broker is lightweight and easy to understand so it could be embedded in other projects.
]]>mqtt moquette netty messaging queueing push-notifications iot internet push eclipsehttps://pinboard.in/https://pinboard.in/u:jm/b:258866cdaffb/"A New Data Structure For Cumulative Frequency Tables"2014-05-02T13:46:18+00:00
http://citeseerx.ist.psu.edu/viewdoc/download;jsessionid=5E9495D2FDC3BFF4FBA425AA6A4B3E0F?doi=10.1.1.14.8917&rep=rep1&type=pdf
jmnetty frequency-tables data-structures algorithms coding binary-tree indexing compression symbol-alphabetshttps://pinboard.in/https://pinboard.in/u:jm/b:f5fcb61a33cc/Google's Open Bidder stack moving from Jetty to Netty2014-04-09T09:55:36+00:00
https://developers.google.com/ad-exchange/rtb/open-bidder/guides/migration-guide#netty
jmOpen Bidder traditionally used Jetty as an embedded webserver, for the critical tasks of accepting connections, processing HTTP requests, managing service threads, etc. Jetty is a robust, but traditional stack that carries the weight and tradeoffs of Servlet’s 15 years old design. For a maximum performance RTB agent that must combine very large request concurrency with very low latencies, and often benefit also from low-level control over the transport, memory management and other issue, a different webserver stack was required. Open Bidder now supports Netty, an asynchronous, event-driven, high-performance webserver stack.
For existing code, the most important impact is that Netty is not compatible with the Servlet API. Its own internal APIs are often too low-level, not to mention proprietary to Netty; so Open Bidder v0.5 introduces some new, stack-neutral APIs for things like HTTP requests and responses, cookies, request handlers, and even simple HTML templating based on Mustache. These APIs will work with both Netty and Jetty. This means you don’t need to change any code to switch between Jetty and Netty; on the other hand, it also means that existing code written for Open Bidder 0.4 may need some changes even if you plan to keep using Jetty.
[....] Netty's superior efficiency is very significant; it supports 50% more traffic in the same hardware, and it maintains a perfect latency distribution even at the peak of its supported load.
This doc is noteworthy on a couple of grounds:
1. the use of Netty in a public API/library, and the additional layer in place to add a friendlier API on top of that. I hope they might consider releasing that part as OSS at some point.
2. I also find it interesting that their API uses protobufs to marshal the message, and they plan in a future release to serialize those to JSON documents -- that makes a lot of sense.]]>apis google protobufs json documents interoperability netty jetty servlets performance javahttps://pinboard.in/https://pinboard.in/u:jm/b:accaa18891ee/Netty Best Practices2014-04-01T22:01:24+00:00
http://normanmaurer.me/presentations/2014-facebook-eng-netty/slides.html
jmnetty java performance optimization facebook slides presentationshttps://pinboard.in/https://pinboard.in/u:jm/b:87af68a8eb5c/[#1259] Add optimized queue for SCMP pattern and use it in NIO and nativ... · 6efac61 · netty/netty2014-03-31T17:03:53+00:00
https://github.com/netty/netty/commit/6efac6179e1e13e6caba2cec6109ce27862efc9a
jmperformance optimization open-source mpsc queues data-structures netty akka javahttps://pinboard.in/https://pinboard.in/u:jm/b:69f7fd9a90b7/Reactor hits GA2013-11-12T13:39:16+00:00
https://spring.io/blog/2013/11/12/it-can-t-just-be-big-data-it-has-to-be-fast-data-reactor-1-0-goes-ga
jm
Reactor provides the necessary abstractions to build high-throughput, low-latency--what we now call "fast data"--applications that absolutely must work with thousands, tens of thousands, or even millions of concurrent requests per second. Modern JVM applications must be built on a solid foundation of asynchronous and reactive components that efficiently manage the execution of a very large number of tasks on a very small number of system threads. Reactor is specifically designed to help you build these kinds of applications without getting in your way or forcing you to work within an opinionated pattern.
Featuring the LMAX Disruptor ringbuffer, the JavaChronicle fast persistent message-passing queue, Groovy closures, and Netty 4.0. This looks very handy indeed....]]>disruptor reactive-programming reactor async libraries java jvm frameworks spring netty fast-datahttps://pinboard.in/https://pinboard.in/u:jm/b:40b56ea65db9/NettoSphere demo2013-11-04T10:24:06+00:00
http://async-io.org/games.html
jmatmosphere netty async java scala websockets sse long-polling http demos gameshttps://pinboard.in/https://pinboard.in/u:jm/b:fd998c63d7d8/Making Storm fly with Netty | Yahoo Engineering2013-10-23T21:09:21+00:00
http://yahooeng.tumblr.com/post/64758709722/making-storm-fly-with-netty
jmnetty async zeromq storm messaging tcp benchmarks yahoo clustershttps://pinboard.in/https://pinboard.in/u:jm/b:0980d14db16f/Building a Modern Website for Scale (QCon NY 2013) [slides]2013-06-17T10:37:00+00:00
http://www.slideshare.net/r39132/q-con-ny2013modernwebsitescalabilityfinal-22989785
jmgc-scout gc java scaling scalability linkedin qcon async threadpools rest slas timeouts networking distcomp netty tcp udp failover fault-tolerance packet-losshttps://pinboard.in/https://pinboard.in/u:jm/b:8766348f43f5/C500k in Action at Urban Airship2012-07-21T20:42:41+00:00
http://urbanairship.com/blog/2010/08/24/c500k-in-action-at-urban-airship/
jmc10k java linux ec2 scaling nio netty urban-airshiphttps://pinboard.in/https://pinboard.in/u:jm/b:db5abfb554d6/