https://pinboard.in/u:jm/public/ recent bookmarks from jm 2026-05-05T11:37:30+00:00 https://github.com/isene/glass jmTerminal emulator written in x86_64 Linux assembly. No libc, no runtime, pure syscalls. Speaks X11 wire protocol directly via Unix socket. Single static binary, ~155KB. No toolkit, no rendering library, no external font engine. The TTF rasterizer (glyph) is embedded in-binary via %include. Just your keystrokes, the X11 server, and the kernel. Part of the CHasm (CHange to ASM) suite: bare (shell), show (file viewer), glass (terminal emulator). ]]> asm x86_64 assembly terminal hacks unix linux glass chasm optimization x11 https://pinboard.in/ https://pinboard.in/u:jm/b:3a109b6e8b07/ 2026-04-27T11:42:47+00:00 https://www.hmpcabral.com/2026/04/26/the-fastest-linux-timestamps/ jm time optimization performance linux libc speed clocks https://pinboard.in/ https://pinboard.in/u:jm/b:cd189cceb922/ 2025-12-08T10:59:48+00:00 https://xania.org/202512/07-division-again jmThe compiler has turned division by a constant ten into a multiply and a shift. There’s a magic constant 0xcccccccd and a shift right of 35! Shifting right by 35 is the same as dividing by 235 - what’s going on? [..] What’s happening is that 0xcccccccd / 2**35 is very close to ⅒ (around 0.10000000000582077). By multiplying our input value by this constant first, then shifting right, we’re doing fixed-point multiplication by ⅒ - which is division by ten. The compiler knows that for all possible unsigned integer values, this trick will always give the right answer. ]]> hacks optimization bit-hacking binary decimal fixed-point arithmetric tricks https://pinboard.in/ https://pinboard.in/u:jm/b:7a0614b312f1/ 2025-04-01T13:30:06+00:00 https://goperf.dev/ jm golang go reference optimization programming performance coding via:hn https://pinboard.in/ https://pinboard.in/u:jm/b:ffdb38949176/ 2025-03-21T10:30:41+00:00 https://byroot.github.io/ruby/performance/2025/03/04/the-pitchfork-story.html jm ruby performance optimisation optimization heap memory fork forking http services servers monolith rails gc https://pinboard.in/ https://pinboard.in/u:jm/b:2839524a8511/ 2025-02-24T11:29:13+00:00 https://aws.amazon.com/blogs/database/timestamp-writes-for-write-hedging-in-amazon-dynamodb/?ck_subscriber_id=512829374 jm Imagine you want a very low p99 read latency. One way to lower tail latencies is to hedge requests. You make a read request and then, if the response doesn’t come back quickly enough, make a second equivalent hedging request and let the two race. First response wins. If the first request suffered a dropped network packet, the second request will probably win. If things are just temporarily slow somewhere, the first request will probably win. Either way, hedging helps improve the p99 metrics, at the cost of some extra read requests. Write hedging has a little more complexity involved, since you want to avoid accidental overwrites during races; this blog post goes into some detail on a technique to do this in DynamoDB, using timestamps. Good stuff. (via Last Week In AWS)]]> via:lwia aws dynamodb write-hedging read-hedging p99 latencies tail-latencies optimization performance algorithms https://pinboard.in/ https://pinboard.in/u:jm/b:2c8e574b8330/ 2025-02-11T14:21:54+00:00 https://www.quantamagazine.org/undergraduate-upends-a-40-year-old-data-science-conjecture-20250210/ jmKrapivin was not held back by the conventional wisdom for the simple reason that he was unaware of it. “I did this without knowing about Yao’s conjecture,” he said. His explorations with tiny pointers led to a new kind of hash table — one that did not rely on uniform probing. And for this new hash table, the time required for worst-case queries and insertions is proportional to (log x)^2 — far faster than x. This result directly contradicted Yao’s conjecture. Farach-Colton and Kuszmaul helped Krapivin show that (log x)^2 is the optimal, unbeatable bound for the popular class of hash tables Yao had written about. Paper here -- https://arxiv.org/abs/2501.02305 .]]> data-structures hash-tables cs programming coding papers optimization open-addressing https://pinboard.in/ https://pinboard.in/u:jm/b:988d8723a281/ 2025-01-23T14:45:35+00:00 https://www.infoq.com/presentations/optimizing-java-app-kubernetes/ jm kubernetes java eks resources ops scaling scalability gc optimization jvm https://pinboard.in/ https://pinboard.in/u:jm/b:2c9522ab8d41/ 2024-12-15T11:43:44+00:00 https://pprof.me/ jm pprof profiling optimization web tools coding https://pinboard.in/ https://pinboard.in/u:jm/b:de5027a7391c/ 2024-09-20T11:59:10+00:00 https://github.com/orf/docker-repack jm docker containers optimization ops zstd https://pinboard.in/ https://pinboard.in/u:jm/b:80a47ec77d03/ 2024-09-13T12:08:48+00:00 https://dougallj.wordpress.com/2022/08/20/faster-zlib-deflate-decompression-on-the-apple-m1-and-x86/ jm via:fanf compression deflate optimization assembly c optimisation hacks https://pinboard.in/ https://pinboard.in/u:jm/b:e410c595df19/ 2023-10-20T11:04:37+00:00 https://finbarrtimbers.substack.com/p/efficient-llm-inference jm llms quantization distillation performance optimization ai ml https://pinboard.in/ https://pinboard.in/u:jm/b:618a980bdedd/ 2023-10-20T11:03:07+00:00 https://finbarr.ca/how-is-llama-cpp-possible/?ref=openml.fyi jm llama2 llms performance optimization c++ memory quantization via:luis-villa https://pinboard.in/ https://pinboard.in/u:jm/b:23f5866ddb16/ 2023-05-15T16:19:55+00:00 https://jack-vanlightly.com/blog/2023/5/15/kafka-vs-redpanda-performance-do-the-claims-add-up jm kafka redpanda benchmarks ec2 aws ssd optimization performance ops https://pinboard.in/ https://pinboard.in/u:jm/b:c155a58ab563/ 2023-04-11T21:03:19+00:00 https://shipilev.net/blog/2015/black-magic-method-dispatch/#_cheating_the_runtime_2 jmProgramming languages like Java provide the facilities for subtyping/polymorphism as one of the ways to construct modular and reusable software. This language choice naturally comes at a price, since there is no hardware support for virtual calls, and therefore runtimes have to emulate this behavior. In many, many cases the performance of method dispatch is not important. Actually, in a vast majority of cases, the low-level performance concerns are not the real concerns. However, there are cases when method dispatch performance is important, and there you need to understand how dispatch works, what runtimes optimize for you, and what you can do to cheat and/or emulate similar behavior in your code. For example, in the course of String Compression work, we were faced with the problem of selecting the coder for a given String. The obvious and highly maintainable approach of creating a Coder interface, a few implementations, and dispatching the virtual calls over it, had met some performance problems on the very tiny benchmarks. Therefore, we needed to contemplate something better. After a few experiments, this post was born as a reference for others who might try to do the same. This post also tangentially touches the inlining of virtual calls, as the natural thing during the optimization. Discovered via this amazing commit: https://github.com/quarkusio/quarkus/commit/65dd4d43e2644db1c87726139280f9704140167c ]]> optimization performance java oo jit coding polymorphism https://pinboard.in/ https://pinboard.in/u:jm/b:fcc32a99ea26/ 2022-09-05T10:57:00+00:00 https://twitter.com/nitsanw/status/1566677642748874753 jmIf you are profiling for a CPU bottleneck [in java], DO NOT RELY ON JVM FLIGHT RECORDER METHOD PROFILING. Not even a little bit. Use `async-profiler` for profiling(`-e cpu,lock,alloc`), with `--jfrsync default/profile` for extra JVM/JDK events. ]]> profiling java performance optimization jvm async-profiler via:twitter https://pinboard.in/ https://pinboard.in/u:jm/b:acdfaf080f4b/ 2022-08-16T10:07:47+00:00 https://discord.com/blog/how-discord-supercharges-network-disks-for-extreme-low-latency jm discord google disks performance optimization scylladb md raid ops https://pinboard.in/ https://pinboard.in/u:jm/b:f663d3221476/ 2022-06-28T15:29:01+00:00 https://dotat.at/@/2022-06-27-tolower-swar.html jm c optimization performance hacks tolower swar simd https://pinboard.in/ https://pinboard.in/u:jm/b:86b30b730c54/ 2022-06-04T16:33:40+00:00 https://mazzo.li/posts/fast-pipes.html jm kernel linux performance pipes vmsplice splice optimization syscalls unix https://pinboard.in/ https://pinboard.in/u:jm/b:8390af0dda94/ 2022-01-24T10:08:22+00:00 https://github.com/netty/netty/pull/10737/files jm simd swar indexof bytebuffer java optimization performance search netty hacks https://pinboard.in/ https://pinboard.in/u:jm/b:b1bb44f3ef08/ 2021-11-29T10:18:31+00:00 https://github.com/WojciechMula/toys/tree/master/swar-utf8-length jm simd swar hacks performance optimization coding utf-8 https://pinboard.in/ https://pinboard.in/u:jm/b:f56d6e491cf3/ 2021-10-27T08:47:52+00:00 https://archive.md/ilW8S#selection-777.0-781.1 jm facebook hate anger negativity metrics kpis optimization engagement social-media https://pinboard.in/ https://pinboard.in/u:jm/b:fcdf81881de7/ 2021-10-16T21:46:58+00:00 https://pkolaczk.github.io/overhead-of-optional/ jm java rust optimization performance hotspots benchmarks optional null https://pinboard.in/ https://pinboard.in/u:jm/b:950a505b2bef/ 2021-05-24T09:39:06+00:00 https://dl.acm.org/doi/10.1145/3064176.3064187 jmWe perform a detailed vertical analysis of application performance atop a range of modern file systems and SSD FTLs. We formalize the "unwritten contract" that clients of SSDs should follow to obtain high performance, and conduct our analysis to uncover application and file system designs that violate the contract. Our analysis, which utilizes a highly detailed SSD simulation underneath traces taken from real workloads and file systems, provides insight into how to better construct applications, file systems, and FTLs to realize robust and sustainable performance. (via Nelson)]]> via:nelson optimization performance ssd disks storage coding architecture https://pinboard.in/ https://pinboard.in/u:jm/b:faf7b0e9a292/ 2020-09-21T10:38:32+00:00 https://www.jeffgeerling.com/blog/2020/raspberry-pi-usb-boot-uasp-trim-and-performance jmIn the past few weeks, I reviewed USB drive performance on the Raspberry Pi 4, and the importance of UASP support for USB drive performance. Both posts generated great discussion, and there were three things I wanted to cover in this follow-up, namely: Which drives support UASP; Real-world performance benchmarks; TRIM support. ]]> raspberry-pi optimization linux trim ssd filesystems usb https://pinboard.in/ https://pinboard.in/u:jm/b:36695789d680/ 2020-06-02T16:46:15+00:00 https://blog.reverberate.org/2020/05/29/hoares-rebuttal-bubble-sorts-comeback.html jmWe’ve seen how crucial it is to understand data dependencies in order to optimize code. Especially hidden memory dependencies between load and stores can greatly influence performance of work loops. Understanding the data dependency graph of code is often where the real performance gains lie, yet very little attention is given to it in the blogosphere. I’ve read many articles about the impact of branch mispredictions, importance of data locality and caches, but much less about data dependencies. I bet that a question like “why are linked lists slow?” is answered by many in terms of locality, caches or unpredictable random memory access. At least I’ve heard those reasons often, even Stroustrup says as much. Those reasons can play a part, but it’s not the main reason. Fundamentally iterating a linked list has a load-to-use on the critical path, making it 5 times slower than iterating a flat array. Furthermore accessing flat arrays allow loop unrolling which can further improve ILP. ]]> data-dependencies sorting algorithms performance optimization coding https://pinboard.in/ https://pinboard.in/u:jm/b:99913961e7a2/ 2020-02-24T17:28:59+00:00 https://www.infoq.com/news/2020/01/blake3-fast-crypto-hash/ jm blake3 blake hashing hashes algorithms speed performance optimization sha https://pinboard.in/ https://pinboard.in/u:jm/b:386b7e9bbdfd/ 2020-02-24T10:55:08+00:00 https://greenlab.di.uminho.pt/ jm coding sustainability power green code optimization papers research https://pinboard.in/ https://pinboard.in/u:jm/b:ef4155d23f24/ 2019-12-19T11:52:12+00:00 https://calendar.perfplanet.com/2019/eco-worriers-saving-the-planet-one-unoptimized-website-at-a-time/ jm sustainability green web http optimization performance ad-blocking gwf https://pinboard.in/ https://pinboard.in/u:jm/b:1247cc866bc4/ 2019-05-27T14:41:11+00:00 https://travisdowns.github.io/blog/2019/05/22/sorting.html jm sorting sort performance optimization radix-sort qsort algorithms https://pinboard.in/ https://pinboard.in/u:jm/b:744ebaa46de8/ 2019-05-15T10:04:47+00:00 http://pages.cs.wisc.edu/~jignesh/publ/Revenge_of_the_Interpolation_Search.pdf jm papers pdf algorithms search interpolation binary-search sorted-data coding optimization performance https://pinboard.in/ https://pinboard.in/u:jm/b:2d559b6ee3d5/ 2017-10-09T10:27:09+00:00 http://nullprogram.com/blog/2017/10/06/ jmThis week I took a crack at writing a branchless UTF-8 decoder: a function that decodes a single UTF-8 code point from a byte stream without any if statements, loops, short-circuit operators, or other sorts of conditional jumps. [...] Why branchless? Because high performance CPUs are pipelined. That is, a single instruction is executed over a series of stages, and many instructions are executed in overlapping time intervals, each at a different stage. Neat hack (via Tony Finch)]]> algorithms optimization unicode utf8 branchless coding c via:fanf https://pinboard.in/ https://pinboard.in/u:jm/b:e6a102583433/ 2017-08-24T16:22:31+00:00 https://github.com/AdoptOpenJDK/jitwatch jmLog analyser and visualiser for the HotSpot JIT compiler. Inspect inlining decisions, hot methods, bytecode, and assembly. View results in the JavaFX user interface. ]]> analysis java jvm performance tools debugging optimization jit https://pinboard.in/ https://pinboard.in/u:jm/b:404ca57f5933/ 2017-06-01T10:08:29+00:00 https://codahale.com/usl4j-and-you/ jm usl scalability java performance optimization benchmarking measurement ops coda-hale https://pinboard.in/ https://pinboard.in/u:jm/b:c184c035e80a/ 2016-07-01T15:17:17+00:00 http://lemire.me/blog/2016/06/30/fast-random-shuffling/ jm coding algorithms performance optimization shuffle shuffling https://pinboard.in/ https://pinboard.in/u:jm/b:ce018caef02a/ 2016-02-13T22:01:51+00:00 https://twitter.com/akpurtell/status/698614296226312192 jm optimization funny terms terminology graduate-student-descent hyperparameters semisupervised-intern-descent tuning interns https://pinboard.in/ https://pinboard.in/u:jm/b:5eb66f4c558b/ 2015-11-17T11:33:13+00:00 http://bannalia.blogspot.fr/2015/06/cache-friendly-binary-search.html jm caches cache-friendly optimization data-locality performance coding algorithms https://pinboard.in/ https://pinboard.in/u:jm/b:45e849ef0f46/ 2015-09-23T13:50:16+00:00 https://www.elastic.co/blog/frame-of-reference-and-roaring-bitmaps jm lucene elasticsearch performance optimization roaring-bitmaps bitmaps frame-of-reference integers algorithms https://pinboard.in/ https://pinboard.in/u:jm/b:5dd4238d15a7/ 2015-09-06T21:53:32+00:00 http://java-performance.info/hashmap-overview-jdk-fastutil-goldman-sachs-hppc-koloboke-trove-january-2015/ jmLarge HashMap overview: JDK, FastUtil, Goldman Sachs, HPPC, Koloboke, Trove – January 2015 version ]]> java performance hashmap hashmaps optimization fastutil hppc jdk koloboke trove data-structures https://pinboard.in/ https://pinboard.in/u:jm/b:d4bb2506c678/ 2015-07-21T09:30:34+00:00 http://vanillajava.blogspot.ie/2015/01/java-lambdas-and-low-latency.html jm lambdas java-8 java performance low-latency optimization peter-lawrey coding escape-analysis https://pinboard.in/ https://pinboard.in/u:jm/b:a175e4b13cb0/ 2015-05-25T13:05:59+00:00 http://blog.cloudera.com/blog/2015/05/working-with-apache-spark-or-how-i-learned-to-stop-worrying-and-love-the-shuffle/ jm spark performance optimization rdd emr big-data cloudera tips akka https://pinboard.in/ https://pinboard.in/u:jm/b:c950623d822d/ 2015-05-09T11:04:44+00:00 http://cglab.ca/~morin/misc/arraylayout/ jmNearly uni­ver­sally, B-trees win when the data gets big enough. ]]> caches cpu performance optimization memory binary-search b-trees algorithms search memory-layout https://pinboard.in/ https://pinboard.in/u:jm/b:ed140ac75aca/ 2015-04-13T11:08:20+00:00 https://twitter.com/igrigorik/status/587446362880344064/photo/1 jm twitter rob-pike via:igrigorik coding rules laws optimization performance algorithms data-structures aphorisms https://pinboard.in/ https://pinboard.in/u:jm/b:8fb4a4612aa1/ 2015-01-10T22:36:45+00:00 https://thethemefoundry.com/blog/why-we-dont-use-a-cdn-spdy-ssl/ jmAll of our assets loaded via the CDN [to our client in Australia] in just under 5 seconds. It only took ~2.7s to get those same assets to our friends down under with SPDY. The performance with no CDN blew the CDN performance out of the water. It is just no comparison. In our case, it really seems that the advantages of SPDY greatly outweigh that of a CDN when it comes to speed. ]]> cdn spdy nginx performance web ssl tls optimization multiplexing tcp ops https://pinboard.in/ https://pinboard.in/u:jm/b:80714627782c/ 2014-12-22T08:45:44+00:00 https://github.com/plasma-umass/coz jmCausal profiling is a novel technique to measure optimization potential. This measurement matches developers' assumptions about profilers: that optimizing highly-ranked code will have the greatest impact on performance. Causal profiling measures optimization potential for serial, parallel, and asynchronous programs without instrumentation of special handling for library calls and concurrency primitives. Instead, a causal profiler uses performance experiments to predict the effect of optimizations. This allows the profiler to establish causality: "optimizing function X will have effect Y," exactly the measurement developers had assumed they were getting all along. I can see this being a good technique to stochastically discover race conditions and concurrency bugs, too.]]> optimization c++ performance coding profiling speed causal-profilers https://pinboard.in/ https://pinboard.in/u:jm/b:236868a21738/ 2014-11-24T09:58:15+00:00 http://blog.cloudera.com/blog/2009/12/7-tips-for-improving-mapreduce-performance/ jm hadoop performance optimization cloudera map-reduce ops https://pinboard.in/ https://pinboard.in/u:jm/b:a7fd21901873/ 2014-09-01T09:02:26+00:00 https://github.com/facebook/folly/blob/master/folly/docs/FBVector.md jm c++ facebook performance algorithms vectors via:fanf optimization https://pinboard.in/ https://pinboard.in/u:jm/b:4903013d2867/ 2014-08-29T21:55:32+00:00 https://github.com/cloudflare/lua-aho-corasick jm optimization speed performance aho-corasick tries string-matching strings algorithms lua c++ via:jgc https://pinboard.in/ https://pinboard.in/u:jm/b:35ea65a2e9a1/ 2014-08-25T10:06:26+00:00 http://www.sciencemag.org/content/345/6199/862.short jmMany of the bike-sharing systems introduced around the world in the past 15 years have the same problem: Riders tend to take some routes and not others. As a result, the bikes tend to collect in a few places, which is a drag for users and a costly problem for the operators, who "rebalance" the system using trucks that take bikes from full stations to empty ones. Now, scientists are coming up with special algorithms to improve this process. One of them, developed by scientists at the Vienna University of Technology and the Austrian Institute of Technology, is now being tested in Vienna's bike-sharing system; another, developed at Cornell University, is already in use in New York City. Timely -- here's what Dublin Bikes looked like this morning: https://twitter.com/jmason/status/503828246086295552 (via Andrew Caines)]]> cycling bike-sharing borisbikes dublinbikes rebalancing fleet availability optimization maths papers toread algorithms https://pinboard.in/ https://pinboard.in/u:jm/b:774c4de5b6f2/ 2014-08-09T11:05:55+00:00 https://code.facebook.com/posts/816473015039157/making-facebook-s-software-infrastructure-more-energy-efficient-with-autoscale/ jm scaling via:eoinbrazil facebook autoscaling power optimization https://pinboard.in/ https://pinboard.in/u:jm/b:0694df54356f/ 2014-08-05T11:22:32+00:00 http://cdn.oreillystatic.com/en/assets/1/event/44/TCP%20and%20the%20Lower%20Bound%20of%20Web%20Performance%20Presentation.pdf jm tcp speed-of-light performance web optimization john-rauser https://pinboard.in/ https://pinboard.in/u:jm/b:1a39b9150f28/ 2014-07-10T14:02:00+00:00 http://research.scee.net/files/presentations/gcapaustralia09/Pitfalls_of_Object_Oriented_Programming_GCAP_09.pdf jm columnar ram memory optimization coding c++ oop data-oriented-programming data cache performance https://pinboard.in/ https://pinboard.in/u:jm/b:09dba48c01ad/ 2014-05-14T13:09:42+00:00 http://shipilev.net/blog/2014/exceptional-performance/ jm java jvm exceptions benchmarking performance optimization coding https://pinboard.in/ https://pinboard.in/u:jm/b:7d2c8fedbc9e/ 2014-04-17T08:56:10+00:00 http://druid.io/blog/2014/02/18/hyperloglog-optimizations-for-real-world-systems.html jm druid.io metamarkets scaling hyperloglog hll algorithms performance optimization counting estimation https://pinboard.in/ https://pinboard.in/u:jm/b:cdabba572a8b/ 2014-04-08T21:54:13+00:00 http://engineering.linkedin.com/garbage-collection/garbage-collection-optimization-high-throughput-and-low-latency-java-applications jm performance optimization linkedin java jvm gc tuning https://pinboard.in/ https://pinboard.in/u:jm/b:77cabe371f7c/ 2014-04-01T22:01:24+00:00 http://normanmaurer.me/presentations/2014-facebook-eng-netty/slides.html jm netty java performance optimization facebook slides presentations https://pinboard.in/ https://pinboard.in/u:jm/b:87af68a8eb5c/ 2014-03-31T17:03:53+00:00 https://github.com/netty/netty/commit/6efac6179e1e13e6caba2cec6109ce27862efc9a jm performance optimization open-source mpsc queues data-structures netty akka java https://pinboard.in/ https://pinboard.in/u:jm/b:69f7fd9a90b7/ 2014-03-19T12:12:51+00:00 http://java-is-the-new-c.blogspot.ie/2013/07/impact-of-large-primitive-arrays-blobs.html jm cms java jvm performance optimization tuning off-heap-storage memory https://pinboard.in/ https://pinboard.in/u:jm/b:026572f118c8/ 2014-01-15T11:01:35+00:00 https://twitter.com/jmason/status/423409032431271936 jm> 6) * 0x19) – 0x10)]]> hacks one-liners coding performance optimization hex conversion numbers ascii https://pinboard.in/ https://pinboard.in/u:jm/b:483c084ba47d/ 2014-01-14T11:11:31+00:00 https://plus.google.com/+IlyaGrigorik/posts/1sxencNkbNS jmGoogle Fonts recently switched to using new Zopfli compression algorithm:  the fonts are ~6% smaller on average, and in some cases up to 15% smaller! [...] What's Zopfli? It's an algorithm that was developed by the compression team at Google that delivers ~3~8% bytesize improvement when compared to gzip with maximum compression. This byte savings comes at a cost of much higher encoding cost, but the good news is, fonts are static files and decompression speed is exactly the same. Google Fonts pays the compression cost once and every clients gets the benefit of smaller download. If you’re curious to learn more about Zopfli: http://bit.ly/Y8DEL4 ]]> zopfli compression gzip fonts google speed optimization https://pinboard.in/ https://pinboard.in/u:jm/b:fb4229faa0c9/ 2013-12-21T20:50:48+00:00 http://www.slideshare.net/cpwatson/cpn302-yourlinuxamioptimizationandperformance jm netflix aws tuning ami perf systemtap tunables sched_batch batch hadoop optimization performance https://pinboard.in/ https://pinboard.in/u:jm/b:5c1292b5cc15/ 2013-12-19T17:13:59+00:00 http://stereopsis.com/radix.html jm sorting programming coding algorithms radix-sort optimization floating-point https://pinboard.in/ https://pinboard.in/u:jm/b:456ae3d8f5c1/ 2013-11-20T11:50:21+00:00 http://mentablog.soliveirajr.com/2012/12/asynchronous-logging-versus-memory-mapped-files/ jm atomic lazyset putordered jmm java synchronization randomaccessfile bytebuffers performance optimization memory disk queues https://pinboard.in/ https://pinboard.in/u:jm/b:e0eaf36231f0/ 2013-10-07T09:51:25+00:00 http://psy-lob-saw.blogspot.ie/2013/10/spsc-revisited-part-iii-fastflow-sparse.html jm nitsanw optimization concurrency java jvm cas spsc queues data-structures algorithms https://pinboard.in/ https://pinboard.in/u:jm/b:76f60b5fe219/ 2013-10-02T12:54:33+00:00 http://low-latency.com/article/groundbreaking-results-high-performance-trading-fpga-and-x86-technologies jmThe enhancement in performance was achieved by providing a fast-path where trades are executed directly by the FPGA under the control of trigger rules processed by the x86 based functions. The latency is reduced further by two additional techniques in the FPGA – inline parsing and pre-emption. As market data enters the switch, the Ethernet frame is parsed serially as bits arrive, allowing partial information to be extracted and matched before the whole frame has been received. Then, instead of waiting until the end of a potential triggering input packet, pre-emption is used to start sending the overhead part of a response which contains the Ethernet, IP, TCP and FIX headers. This allows completion of an outgoing order almost immediately after the end of the triggering market feed packet. Insane stuff. (Via Martin Thompson)]]> via:martin-thompson insane speed low-latency fpga fast-path trading stock-markets performance optimization ethernet https://pinboard.in/ https://pinboard.in/u:jm/b:e1e6cba06648/ 2013-09-18T21:34:06+00:00 http://www.infoq.com/articles/tuning-tips-G1-GC jmg1gc gc java jvm tuning ops optimization https://pinboard.in/ https://pinboard.in/u:jm/b:6b12d8d218aa/ 2013-09-08T22:49:35+00:00 http://edinburghhacklab.com/2013/09/probabalistic-scraping-of-plain-text-tables/ jmRecently I have been banging my head trying to import a ton of OCR acquired data expressed in tabular form. I think I have come up with a neat approach using probabilistic reasoning combined with mixed integer programming. The method is pretty robust to all sorts of real world issues. In particular, the method leverages topological understanding of tables, encodes it declaratively into a mixed integer/linear program, and integrates weak probabilistic signals to classify the whole table in one go (at sub second speeds). This method can be used for any kind of classification where you have strong logical constraints but noisy data. (via proggit) ]]> scraping tables ocr probabilistic linear-programming optimization machine-learning via:proggit https://pinboard.in/ https://pinboard.in/u:jm/b:aea5b4ffbc36/ 2013-06-19T10:07:19+00:00 http://www.infoq.com/articles/Java_Garbage_Collection_Distilled jmSerial, Parallel, Concurrent, CMS, G1, Young Gen, New Gen, Old Gen, Perm Gen, Eden, Tenured, Survivor Spaces, Safepoints, and the hundreds of JVM start-up flags. Does this all baffle you when trying to tune the garbage collector while trying to get the required throughput and latency from your Java application? If it does then don’t worry, you are not alone. Documentation describing garbage collection feels like man pages for an aircraft. Every knob and dial is detailed and explained but nowhere can you find a guide on how to fly. This article will attempt to explain the tradeoffs when choosing and tuning garbage collection algorithms for a particular workload. ]]> gc java garbage-collection coding cms g1 jvm optimization https://pinboard.in/ https://pinboard.in/u:jm/b:f59114d2c748/ 2013-06-14T16:15:53+00:00 http://blog.aggregateknowledge.com/2011/12/12/big-memory-part-4/ jm java collections benchmarks performance speed coding data-structures optimization https://pinboard.in/ https://pinboard.in/u:jm/b:bf55fa5e7127/ 2013-06-14T16:09:12+00:00 http://fastutil.di.unimi.it/ jmfastutil extends the Java™ Collections Framework by providing type-specific maps, sets, lists and queues with a small memory footprint and fast access and insertion; provides also big (64-bit) arrays, sets and lists, and fast, practical I/O classes for binary and text files. It is free software distributed under the Apache License 2.0. It requires Java 6 or newer. used by Facebook (along with Apache Giraph, Netty, Unsafe) to speed up "weekend Hive jobs" to "coffee breaks". http://www.slideshare.net/nitayj/2013-0603-berlin-buzzwords]]> via:highscalability facebook giraph optimization java speed fastutil collections data-structures https://pinboard.in/ https://pinboard.in/u:jm/b:0d6dc4177b25/