https://pinboard.in/u:jm/public/ recent bookmarks from jm 2025-05-19T09:03:07+00:00 https://mcyoung.xyz/2023/03/29/rseq-checkout/ jm via:fanf linux concurrency multiprocessing rseq cpu-local https://pinboard.in/ https://pinboard.in/u:jm/b:d8ecd0840341/ 2025-05-01T12:09:01+00:00 https://github.com/ericvolp12/atomic-bloom jm atomic concurrency data-structures bloom-filters performance bluesky sets golang https://pinboard.in/ https://pinboard.in/u:jm/b:2ebe9e635c87/ 2023-06-23T09:28:05+00:00 https://sqlite.org/wal.html jm databases performance unix sqlite wordpress django wal concurrency https://pinboard.in/ https://pinboard.in/u:jm/b:a64af67329c6/ 2019-03-02T21:21:02+00:00 https://songlh.github.io/paper/go-study.pdf jm via:dehora golang go concurrency bugs lint synchronization threading threads bug-detection https://pinboard.in/ https://pinboard.in/u:jm/b:e389d307df9b/ 2016-11-02T17:53:21+00:00 https://blog.acolyer.org/2016/11/02/memc3-compact-and-concurrent-memcache-with-dumber-caching-and-smarter-hashing/ jmAn improved hashing algorithm called optimistic cuckoo hashing, and a CLOCK-based eviction algorithm that works in tandem with it. They are evaluated in the context of Memcached, where combined they give up to a 30% memory usage reduction and up to a 3x improvement in queries per second as compared to the default Memcached implementation on read-heavy workloads with small objects (as is typified by Facebook workloads). ]]> memcached performance key-value-stores storage databases cuckoo-hashing algorithms concurrency caching cache-eviction memory throughput https://pinboard.in/ https://pinboard.in/u:jm/b:db93b3a89ad7/ 2016-09-26T10:00:52+00:00 http://www.perfdynamics.com/Manifesto/USLscalability.html jm usl performance scalability concurrency capacity measurement excel equations metrics https://pinboard.in/ https://pinboard.in/u:jm/b:ab7e86dd0bb0/ 2016-06-01T11:55:13+00:00 https://github.com/ztellman/dirigiste jm async jvm dirigiste java threadpools concurrency utilization capacity executors object-pools object-pooling latency https://pinboard.in/ https://pinboard.in/u:jm/b:5092c7f0c12e/ 2016-03-07T11:24:20+00:00 https://github.com/conversant/disruptor jm disruptor blocking-queues queues queueing data-structures algorithms java conversant concurrency performance https://pinboard.in/ https://pinboard.in/u:jm/b:502056282b58/ 2016-01-04T10:42:16+00:00 https://www.voxxed.com/blog/2015/12/importance-tuning-thread-pools/ jm hystrix threadpools concurrency java jvm backpressure littles-law capacity https://pinboard.in/ https://pinboard.in/u:jm/b:d8e4a0101363/ 2015-05-08T16:33:16+00:00 http://belliottsmith.com/injector/ jmThis honestly fits a narrow niche, but one that is gaining in popularity. If your messages take > 100μs to process, or your worker threads are consistently saturated, the standard ThreadPoolExecutor is likely perfectly adequate for your needs. If, on the other hand, you’re able to engineer your system to operate with one application thread per physical core you are probably better off looking at an approach like the LMAX Disruptor. However, if you fall in the crack in between these two scenarios, or are seeing a significant portion of time spent in futex calls and need a drop in ExecutorService to take the edge off, the injector may well be worth a look. ]]> performance java executor concurrency disruptor algorithms coding threads threadpool injector https://pinboard.in/ https://pinboard.in/u:jm/b:b2f16d258d53/ 2015-03-27T09:36:04+00:00 http://muratbuffalo.blogspot.co.uk/2015/03/paper-review-simple-testing-can-prevent.html jm race-conditions startup bugs failure fault-tolerance hbase redis reliability ops papers concurrency exception-handling cassandra hdfs mapreduce https://pinboard.in/ https://pinboard.in/u:jm/b:3dd7b48e5fed/ 2015-03-24T11:32:35+00:00 https://github.com/ben-manes/caffeine jm cache java8 java guava caching concurrency data-structures coding https://pinboard.in/ https://pinboard.in/u:jm/b:2a3239aaf088/ 2015-01-25T08:50:22+00:00 https://github.com/JCTools/JCTools jmJava Concurrency Tools for the JVM. This project aims to offer some concurrent data structures currently missing from the JDK: Bounded lock free queues SPSC/MPSC/SPMC/MPMC variations for concurrent queues Alternative interfaces for queues (experimental) Offheap concurrent ring buffer for ITC/IPC purposes (experimental) Executor (planned) ]]> concurrency lock-free data-structures queues jvm java https://pinboard.in/ https://pinboard.in/u:jm/b:48920e47e7f3/ 2014-12-09T16:42:44+00:00 http://www.xaprb.com/blog/2014/12/08/eventual-consistency-simpler-than-mvcc/ jmSince I am not ready to assert that there’s a distributed system I know to be better and simpler than eventually consistent datastores, and since I certainly know that InnoDB’s MVCC implementation is full of complexities, for right now I am probably in the same position most of my readers are: the two viable choices seem to be single-node MVCC and multi-node eventual consistency. And I don’t think MVCC is the simpler paradigm of the two. ]]> nosql concurrency databases mysql riak voldemort eventual-consistency reliability storage baron-schwartz mvcc innodb postgresql https://pinboard.in/ https://pinboard.in/u:jm/b:0dddeb567400/ 2014-11-28T16:53:54+00:00 http://martin.kleppmann.com/2014/11/25/hermitage-testing-the-i-in-acid.html jm[Hermitage is] a test suite for databases which probes for a variety of concurrency issues, and thus allows a fair and accurate comparison of isolation levels. Each test case simulates a particular kind of race condition that can happen when two or more transactions concurrently access the same data. Each test can pass (if the database’s implementation of isolation prevents the race condition from occurring) or fail (if the race condition does occur). ]]> acid architecture concurrency databases nosql https://pinboard.in/ https://pinboard.in/u:jm/b:edfb2ab71a2b/ 2014-11-25T12:28:16+00:00 http://www.nurkiewicz.com/2014/11/executorservice-10-tips-and-tricks.html jm concurrency java jvm threading threads executors coding https://pinboard.in/ https://pinboard.in/u:jm/b:35ca20533835/ 2014-11-17T12:17:49+00:00 http://stuff-gil-says.blogspot.ie/2014/11/writerreaderphaser-story-about-new.html jmHave you ever had a need for logging or analyzing data that is actively being updated? Have you ever wanted to do that without stalling the writers (recorders) in any way? If so, then WriterReaderPhaser is for you.  I'm not talking about logging messages or text lines here.  I'm talking about data.  Data larger than one word of memory.  Data that holds actual interesting state. Data that keeps being updated, but needs to be viewed in a stable and coherent way for analysis or logging.  Data like frame buffers. Data like histograms.  Data like usage counts. Data that changes. see also Left-Right: http://concurrencyfreaks.blogspot.ie/2013/12/left-right-concurrency-control.html]]> phasers data-structures concurrency primitives algorithms performance wait-free https://pinboard.in/ https://pinboard.in/u:jm/b:919ce0908e15/ 2014-09-17T14:29:55+00:00 http://sourceforge.net/projects/ccfreaks/files/papers/LeftRight/leftright-extended.pdf jm left-right concurrency multithreading wait-free blocking realtime gc latency reader-writer locking synchronization java https://pinboard.in/ https://pinboard.in/u:jm/b:71e20ba2b8b1/ 2014-06-30T22:03:56+00:00 http://googletesting.blogspot.ie/2014/06/threadsanitizer-slaughtering-data-races.html jm concurrency bugs valgrind threadsanitizer threading deadlocks mutexes locking synchronization coding testing https://pinboard.in/ https://pinboard.in/u:jm/b:db1d9b5fef05/ 2014-06-19T15:18:03+00:00 http://hackingdistributed.com/2014/06/18/hyperleveldb-improvements/ jm hyperdex hyperleveldb leveldb rocksdb concurrency lock-free storage persistence https://pinboard.in/ https://pinboard.in/u:jm/b:8224fb82bc16/ 2014-05-08T13:34:52+00:00 https://news.ycombinator.com/item?id=7711974 jmat higher contention, the CPU was choking everything. Switching over to Go removed that contention for us, which was the primary issue that we were seeing. ]]> python languages concurrency go threading gevent scalability disqus realtime hn https://pinboard.in/ https://pinboard.in/u:jm/b:7735324765d8/ 2014-04-22T22:20:43+00:00 http://psy-lob-saw.blogspot.ie/2014/04/notes-on-concurrent-ring-buffer-queue.html jm jaq nitsanw atomic concurrency data-structures ring-buffers queueing queues algorithms https://pinboard.in/ https://pinboard.in/u:jm/b:ce4599f4a093/ 2014-04-10T20:55:17+00:00 http://www.bailis.org/blog/scalable-atomic-visibility-with-ramp-transactions/ jmWe’ve developed three new algorithms—called Read Atomic Multi-Partition (RAMP) Transactions—for ensuring atomic visibility in partitioned (sharded) databases: either all of a transaction’s updates are observed, or none are. [...] How they work: RAMP transactions allow readers and writers to proceed concurrently. Operations race, but readers autonomously detect the races and repair any non-atomic reads. The write protocol ensures readers never stall waiting for writes to arrive. Why they scale: Clients can’t cause other clients to stall (via synchronization independence) and clients only have to contact the servers responsible for items in their transactions (via partition independence). As a consequence, there’s no mutual exclusion or synchronous coordination across servers. The end result: RAMP transactions outperform existing approaches across a variety of workloads, and, for a workload of 95% reads, RAMP transactions scale to over 7 million ops/second on 100 servers at less than 5% overhead. ]]> scale synchronization databases distcomp distributed ramp transactions scalability peter-bailis protocols sharding concurrency atomic partitions https://pinboard.in/ https://pinboard.in/u:jm/b:bb652343d9e6/ 2014-04-09T09:19:24+00:00 http://www.cs.cmu.edu/~hl/papers/mica-nsdi2014.pdf jm mica in-memory memory ram key-value-stores storage smp dpdk multicore memcached concurrency https://pinboard.in/ https://pinboard.in/u:jm/b:1b85262ba3f6/ 2013-12-05T14:04:50+00:00 http://www.elevatedcode.com/2013/05/07/flock-for-cron-jobs.html jm cron concurrency unix linux flock locking ops https://pinboard.in/ https://pinboard.in/u:jm/b:1d8eca4336f5/ 2013-12-02T23:07:48+00:00 http://www.javaspecialists.eu/archive/Issue215.html jm doug-lea concurrency coding java-8 java threads https://pinboard.in/ https://pinboard.in/u:jm/b:3aa6c6135e23/ 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-09-03T22:29:45+00:00 https://issues.apache.org/jira/browse/CASSANDRA-5582 jm disruptor cassandra java p99 latency speed performance concurrency via:kellabyte https://pinboard.in/ https://pinboard.in/u:jm/b:70d101c721e7/ 2013-08-27T13:44:58+00:00 http://mechanical-sympathy.blogspot.co.uk/2013/08/lock-based-vs-lock-free-concurrent.html jm concurrency java threads lock-free locking compare-and-set cas atomic jsr166 microbenchmarks performance https://pinboard.in/ https://pinboard.in/u:jm/b:bdebec8819d5/ 2013-06-21T08:58:54+00:00 http://psy-lob-saw.blogspot.ie/2013/06/java-concurrent-counters-by-numbers.html jm counters concurrency threads java jvm atomic https://pinboard.in/ https://pinboard.in/u:jm/b:ede985f5ed91/ 2013-04-25T13:53:04+00:00 http://techblog.netflix.com/2013/02/rxjava-netflix-api.html jmFunctional reactive programming offers efficient execution and composition by providing a collection of operators capable of filtering, selecting, transforming, combining and composing Observable's. The Observable data type can be thought of as a "push" equivalent to Iterable which is "pull". With an Iterable, the consumer pulls values from the producer and the thread blocks until those values arrive. By contrast with the Observable type, the producer pushes values to the consumer whenever values are available. This approach is more flexible, because values can arrive synchronously or asynchronously. ]]> concurrency java jvm threads thread-safety coding rx frp fp functional-programming reactive functional async observable https://pinboard.in/ https://pinboard.in/u:jm/b:553199ccea41/ 2013-04-03T17:06:34+00:00 http://pagesperso-systeme.lip6.fr/Marc.Shapiro/papers/RR-6956.pdf jm Shared read-only data is easy to scale by using well-understood replication techniques. However, sharing mutable data at a large scale is a dicult problem, because of the CAP impossibility result [5]. Two approaches dominate in practice. One ensures scalability by giving up consistency guarantees, for instance using the Last-Writer-Wins (LWW) approach [7]. The alternative guarantees consistency by serialising all updates, which does not scale beyond a small cluster [12]. Optimistic replication allows replicas to diverge, eventually resolving conflicts either by LWW-like methods or by serialisation [11]. In some (limited) cases, a radical simplication is possible. If concurrent updates to some datum commute, and all of its replicas execute all updates in causal order, then the replicas converge.1 We call this a Commutative Replicated Data Type (CRDT). The CRDT approach ensures that there are no conflicts, hence, no need for consensus-based concurrency control. CRDTs are not a universal solution, but, perhaps surprisingly, we were able to design highly useful CRDTs. This new research direction is promising as it ensures consistency in the large scale at a low cost, at least for some applications. ]]> consistency algorithms concurrency crdts distcomp data https://pinboard.in/ https://pinboard.in/u:jm/b:d78072311d88/ 2013-03-25T11:26:31+00:00 http://lars-lab.jpl.nasa.gov/JPL_Coding_Standard_Java.pdf jm compile with checks turned on; apply static analysis; document public elements; write unit tests; use the standard naming conventions; do not override field or class names; make imports explicit; do not have cyclic package and class dependencies; obey the contract for equals(); define both equals() and hashCode(); define equals when adding fields; define equals with parameter type Object; do not use finalizers; do not implement the Cloneable interface; do not call nonfinal methods in constructors; select composition over inheritance; make fields private; do not use static mutable fields; declare immutable fields final; initialize fields before use; use assertions; use annotations; restrict method overloading; do not assign to parameters; do not return null arrays or collections; do not call System.exit; have one concept per line; use braces in control structures; do not have empty blocks; use breaks in switch statements; end switch statements with default; terminate if-else-if with else; restrict side effects in expressions; use named constants for non-trivial literals; make operator precedence explicit; do not use reference equality; use only short-circuit logic operators; do not use octal values; do not use floating point equality; use one result type in conditional expressions; do not use string concatenation operator in loops; do not drop exceptions; do not abruptly exit a finally block; use generics; use interfaces as types when available; use primitive types; do not remove literals from collections; restrict numeric conversions; program against data races; program against deadlocks; do not rely on the scheduler for synchronization; wait and notify safely; reduce code complexity ]]> nasa java reference guidelines coding-standards jpl reliability software coding oo concurrency findbugs bugs https://pinboard.in/ https://pinboard.in/u:jm/b:5892be45c902/ 2013-02-26T17:06:21+00:00 http://brooker.co.za/blog/2012/09/10/volatile.html jmIt appears as though reads to volatile variables are not free in Java on x86, or at least on the tested setup. It's true that the difference isn't so huge (especially for the read-only case) that it'll make a difference in any but the more performance sensitive case, but that's a different statement from free. ]]> volatile concurrency jvm performance java marc-brooker https://pinboard.in/ https://pinboard.in/u:jm/b:52cbaf6b95b9/ 2013-02-01T11:49:23+00:00 http://stackoverflow.com/questions/14010906/given-that-hashmaps-in-jdk1-6-and-above-cause-problems-with-multi-threading-how jm java hashmap concurrency bugs fail security hashing jdk via:cscotta https://pinboard.in/ https://pinboard.in/u:jm/b:8b7f56ad583d/ 2013-01-08T22:31:34+00:00 http://www.reddit.com/r/programming/comments/164yjy/a_nonblocking_hashtable_by_dr_cliff_click/ jm data-structures algorithms non-blocking concurrency threading multicore cliff-click azul maps java boundary https://pinboard.in/u:jm/b:d2882c65989d/ 2012-12-17T21:43:25+00:00 http://jeremymanson.blogspot.com/2011/04/cliff-click-in-jvm-does-what.html jm presentation concurrency jvm video java youtube cliff-click https://pinboard.in/ https://pinboard.in/u:jm/b:1c8bbb3bbf5d/ 2012-11-24T21:39:32+00:00 http://mechanical-sympathy.blogspot.com/2011/07/memory-barriersfences.html jm architecture hardware programming java concurrency volatile jsr-133 https://pinboard.in/ https://pinboard.in/u:jm/b:b161ec6482e6/ 2012-10-05T23:22:21+00:00 http://www.azulsystems.com/events/javaone_2008/2008_CodingNonBlock.pdf jm nonblockinghashtable data-structures hashmap concurrency scaling java jvm https://pinboard.in/ https://pinboard.in/u:jm/b:7284343ec731/ 2012-09-12T19:44:41+00:00 http://edwwang.com/blog/2012/02/10/concurrent-hashmap-benchmark/ jm concurrency benchmarks hashmap map data-structures java jvm snaptree https://pinboard.in/ https://pinboard.in/u:jm/b:df6799ed41e7/ 2012-09-01T08:25:05+00:00 http://mechanical-sympathy.blogspot.ie/2011/11/locks-condition-variables-latency.html jm Firstly, this is 3 orders of magnitude greater latency than what I illustrated in the previous article using just memory barriers to signal between threads. This cost comes about because the kernel needs to get involved to arbitrate between the threads for the lock, and then manage the scheduling for the threads to awaken when the condition is signalled. The one-way latency to signal a change is pretty much the same as what is considered current state of the art for network hops between nodes via a switch. It is possible to get ~1µs latency with InfiniBand and less than 5µs with 10GigE and user-space IP stacks. Secondly, the impact is clear when letting the OS choose what CPUs the threads get scheduled on rather than pinning them manually. I've observed this same issue across many use cases whereby Linux, in default configuration for its scheduler, will greatly impact the performance of a low-latency system by scheduling threads on different cores resulting in cache pollution. Windows by default seems to make a better job of this. ]]> locking concurrency java jvm signalling locks linux threading https://pinboard.in/ https://pinboard.in/u:jm/b:4612004e61bd/ 2012-09-01T08:20:24+00:00 http://mechanical-sympathy.blogspot.ie/2011/09/single-writer-principle.html jmOne Thread300
One Thread with Memory Barrier4,700
One Thread with CAS5,700
Two Threads with CAS18,000
One Thread with Lock10,000
Two Threads with Lock118,000
Undoubtedly not realistic for a lot of cases, but it's still useful for order-of-magnitude estimates of locking cost. Bottom line: don't lock if you can avoid it, even with 'volatile' or AtomicFoo types.]]> java jvm performance coding concurrency threading cas locking https://pinboard.in/ https://pinboard.in/u:jm/b:46f185528972/ 2012-09-01T07:50:40+00:00 http://docs.guava-libraries.googlecode.com/git-history/v13.0.1/javadoc/com/google/common/util/concurrent/Striped.html jmA striped Lock/Semaphore/ReadWriteLock. This offers the underlying lock striping similar to that of ConcurrentHashMap in a reusable form, and extends it for semaphores and read-write locks. Conceptually, lock striping is the technique of dividing a lock into many stripes, increasing the granularity of a single lock and allowing independent operations to lock different stripes and proceed concurrently, instead of creating contention for a single lock.
The guarantee provided by this class is that equal keys lead to the same lock (or semaphore), i.e. if (key1.equals(key2)) then striped.get(key1) == striped.get(key2) (assuming Object.hashCode() is correctly implemented for the keys). Note that if key1 is not equal to key2, it is not guaranteed that striped.get(key1) != striped.get(key2); the elements might nevertheless be mapped to the same lock. The lower the number of stripes, the higher the probability of this happening.
Prior to this class, one might be tempted to use Map, where K represents the task. This maximizes concurrency by having each unique key mapped to a unique lock, but also maximizes memory footprint. On the other extreme, one could use a single lock for all tasks, which minimizes memory footprint but also minimizes concurrency. Instead of choosing either of these extremes, Striped allows the user to trade between required concurrency and memory footprint. For example, if a set of tasks are CPU-bound, one could easily create a very compact Striped of availableProcessors() * 4 stripes, instead of possibly thousands of locks which could be created in a Map structure. ]]> locking concurrency java guava semaphores coding via:twitter https://pinboard.in/ https://pinboard.in/u:jm/b:7f8bcbb66762/ 2012-08-19T14:35:59+00:00 http://www.1024cores.net/home jm algorithms concurrency articles dmitry-vyukov go c++ coding via:sergio-bossa https://pinboard.in/ https://pinboard.in/u:jm/b:550e96245d4d/ 2012-04-13T09:20:39+00:00 http://highscalability.com/blog/2012/3/6/ask-for-forgiveness-programming-or-how-well-program-1000-cor.html jm race-and-repair concurrency coding ibm parallelism parallel david-ungar cap multicore https://pinboard.in/ https://pinboard.in/u:jm/b:fd12be6fa86f/ 2012-03-02T14:02:22+00:00 http://techblog.netflix.com/2012/02/fault-tolerance-in-high-volume.html jm netflix architecture concurrency distributed failover ha resiliency fail-fast failsafe soa fault-tolerance https://pinboard.in/ https://pinboard.in/u:jm/b:d34c188eb195/ 2011-11-23T09:52:35+00:00 http://stackoverflow.com/questions/6559308/how-does-lmaxs-disruptor-pattern-work jm via:filippo servers seda queueing concurrency disruptor patterns latency trading performance ring-buffers https://pinboard.in/ https://pinboard.in/u:jm/b:388ee9929e15/ 2011-03-27T22:20:47+00:00 http://akka.io/ jm scala java concurrency scalability apache akka actors erlang fault-tolerance events https://pinboard.in/u:jm/b:d8d97dabbd34/ 2010-10-19T20:12:17+00:00 http://mdm.berlios.de/usage.html jm mdm unix concurrency shell linux forking background xargs parallelism https://pinboard.in/u:jm/b:0868e2c3b4d8/ 2010-10-19T20:10:05+00:00 http://savannah.gnu.org/projects/parallel jm via:fanf unix concurrency gnu linux job parallel scripting shell https://pinboard.in/u:jm/b:603200e22e92/ 2010-02-10T14:45:36+00:00 http://www.eflorenzano.com/blog/post/how-do-we-kick-our-synchronous-addiction/ jm via:jzawodny coding python javascript scalability ruby concurrency erlang async node.js twisted https://pinboard.in/u:jm/b:c44bdbe63e1d/ 2009-10-21T10:09:18+00:00 http://www.zlib.net/pigz/ jm adler pigz gzip compression performance concurrency shell parallel multicore zip software https://pinboard.in/u:jm/b:3488243c8811/