pzemtsov.github.io Open in urlscan Pro
2606:50c0:8002::153  Public Scan

Form analysis
0 forms found in the DOM

Text Content

PAVEL ZEMTSOV


EXPERIMENTS IN PROGRAM OPTIMISATION


 * All articles
 * Stories
 * Tags



De-multiplexing of E1 streams

 * 15 Apr 2014 » De-multiplexing of E1 streams in Java
 * 02 May 2014 » De-multiplexing of E1 stream: converting to C
 * 12 May 2014 » The mystery of an unstable performance
 * 15 May 2014 » How to make C run as fast as Java
 * 18 May 2014 » Size does matter
 * 04 Jun 2014 » Fast E1 de-multiplexing in C using SSE/AVX
 * 21 Sep 2014 » A bug story: testing your test code
 * 01 Oct 2014 » How to transpose a 16×16 byte matrix using SSE
 * 21 Oct 2014 » Bug story 2: Unrolling the 16×16 matrix transposition, or be
   careful with macros

Performance of various callback mechanisms

 * 28 Oct 2014 » Macros, call by name, lambda and Jensen's device
 * 14 Nov 2014 » Lambdas and other callbacks in Java

How cache affects performance

 * 24 Nov 2014 » How cache affects demultiplexing of E1
 * 24 Dec 2014 » More experiments with cache

Effect of stream buffering

 * 19 Jan 2015 » On the benefits of stream buffering in Java
 * 01 Feb 2015 » Standard input, buffering and affinity mask

Conway's Game of Life

 * 24 Apr 2015 » Game of Life, hash tables and hash codes
 * 10 Sep 2015 » Hash functions: disassembling and measuring performance
 * 17 Sep 2015 » Optimising division-based hash functions
 * 12 Oct 2015 » The fun and the cost of refactoring
 * 20 Oct 2015 » More optimisations of division-based hash: Karatsuba's method
 * 28 Oct 2015 » Don't trust a micro-benchmark
 * 21 Nov 2015 » CRC32: intrinsic, Java or C with JNI?
 * 04 Dec 2015 » Optimising the hash-based Life
 * 14 Dec 2015 » Choosing the hash map's capacity
 * 31 Jan 2016 » Home-made hash tables in Java
 * 21 Mar 2016 » Home-made hash tables in C++: a race against Java

Numbers from scratch

 * 22 Dec 2015 » Implementing Peano arithmetic
 * 10 Jan 2016 » Home-made binary numbers

Multi-threading performance

 * 08 Dec 2016 » Turbo Boost and multi-threading performance
 * 22 Mar 2017 » Statistical variables in Java: not quite legal but very fast

Assorted

 * 05 May 2014 » One handy C idiom: multi-statement macro
 * 07 May 2014 » From macros to templates
 * 16 Oct 2016 » Searching in a constant set using conflict-free hashing
 * 06 Nov 2016 » A bug story: data alignment on x86
 * 23 Jul 2017 » The slow currentTimeMillis()
 * 18 Jul 2018 » Building a fast queue between C++ and Java
 * 17 Jan 2019 » To allocate or to pool?
 * 13 Apr 2019 » Searching for a better indexOf
 * 26 Sep 2019 » Making a char searcher in C
 * 07 Oct 2019 » Abnormal string hashing



optimisation performance de-multiplexing Java C C++ macro meta-programming idiom
templates GCC SSE AVX bug cache streams socket buffering stdin stdout affinity
hashmap life assembly refactoring design-patterns Peano search matching
alignment parallel real-time Linux Windows

 * 15 Apr 2014 » De-multiplexing of E1 streams in Java
 * 02 May 2014 » De-multiplexing of E1 stream: converting to C
 * 12 May 2014 » The mystery of an unstable performance
 * 15 May 2014 » How to make C run as fast as Java
 * 18 May 2014 » Size does matter
 * 04 Jun 2014 » Fast E1 de-multiplexing in C using SSE/AVX
 * 01 Oct 2014 » How to transpose a 16×16 byte matrix using SSE
 * 21 Oct 2014 » Bug story 2: Unrolling the 16×16 matrix transposition, or be
   careful with macros
 * 28 Oct 2014 » Macros, call by name, lambda and Jensen's device
 * 14 Nov 2014 » Lambdas and other callbacks in Java
 * 24 Nov 2014 » How cache affects demultiplexing of E1
 * 24 Dec 2014 » More experiments with cache
 * 19 Jan 2015 » On the benefits of stream buffering in Java
 * 01 Feb 2015 » Standard input, buffering and affinity mask
 * 24 Apr 2015 » Game of Life, hash tables and hash codes
 * 10 Sep 2015 » Hash functions: disassembling and measuring performance
 * 17 Sep 2015 » Optimising division-based hash functions
 * 12 Oct 2015 » The fun and the cost of refactoring
 * 20 Oct 2015 » More optimisations of division-based hash: Karatsuba's method
 * 28 Oct 2015 » Don't trust a micro-benchmark
 * 21 Nov 2015 » CRC32: intrinsic, Java or C with JNI?
 * 04 Dec 2015 » Optimising the hash-based Life
 * 14 Dec 2015 » Choosing the hash map's capacity
 * 31 Jan 2016 » Home-made hash tables in Java
 * 21 Mar 2016 » Home-made hash tables in C++: a race against Java
 * 16 Oct 2016 » Searching in a constant set using conflict-free hashing
 * 06 Nov 2016 » A bug story: data alignment on x86
 * 08 Dec 2016 » Turbo Boost and multi-threading performance
 * 22 Mar 2017 » Statistical variables in Java: not quite legal but very fast
 * 23 Jul 2017 » The slow currentTimeMillis()
 * 18 Jul 2018 » Building a fast queue between C++ and Java
 * 17 Jan 2019 » To allocate or to pool?
 * 13 Apr 2019 » Searching for a better indexOf
 * 26 Sep 2019 » Making a char searcher in C
 * 07 Oct 2019 » Abnormal string hashing

 * 15 Apr 2014 » De-multiplexing of E1 streams in Java
 * 02 May 2014 » De-multiplexing of E1 stream: converting to C
 * 19 Jan 2015 » On the benefits of stream buffering in Java
 * 01 Feb 2015 » Standard input, buffering and affinity mask

 * 15 Apr 2014 » De-multiplexing of E1 streams in Java
 * 02 May 2014 » De-multiplexing of E1 stream: converting to C
 * 24 Nov 2014 » How cache affects demultiplexing of E1
 * 24 Dec 2014 » More experiments with cache

 * 15 Apr 2014 » De-multiplexing of E1 streams in Java
 * 15 May 2014 » How to make C run as fast as Java
 * 14 Nov 2014 » Lambdas and other callbacks in Java
 * 19 Jan 2015 » On the benefits of stream buffering in Java
 * 01 Feb 2015 » Standard input, buffering and affinity mask
 * 24 Apr 2015 » Game of Life, hash tables and hash codes
 * 10 Sep 2015 » Hash functions: disassembling and measuring performance
 * 17 Sep 2015 » Optimising division-based hash functions
 * 12 Oct 2015 » The fun and the cost of refactoring
 * 20 Oct 2015 » More optimisations of division-based hash: Karatsuba's method
 * 28 Oct 2015 » Don't trust a micro-benchmark
 * 21 Nov 2015 » CRC32: intrinsic, Java or C with JNI?
 * 04 Dec 2015 » Optimising the hash-based Life
 * 14 Dec 2015 » Choosing the hash map's capacity
 * 22 Dec 2015 » Implementing Peano arithmetic
 * 10 Jan 2016 » Home-made binary numbers
 * 31 Jan 2016 » Home-made hash tables in Java
 * 21 Mar 2016 » Home-made hash tables in C++: a race against Java
 * 08 Dec 2016 » Turbo Boost and multi-threading performance
 * 22 Mar 2017 » Statistical variables in Java: not quite legal but very fast
 * 23 Jul 2017 » The slow currentTimeMillis()
 * 18 Jul 2018 » Building a fast queue between C++ and Java
 * 17 Jan 2019 » To allocate or to pool?
 * 13 Apr 2019 » Searching for a better indexOf
 * 07 Oct 2019 » Abnormal string hashing

 * 02 May 2014 » De-multiplexing of E1 stream: converting to C
 * 05 May 2014 » One handy C idiom: multi-statement macro
 * 07 May 2014 » From macros to templates
 * 12 May 2014 » The mystery of an unstable performance
 * 15 May 2014 » How to make C run as fast as Java
 * 18 May 2014 » Size does matter
 * 04 Jun 2014 » Fast E1 de-multiplexing in C using SSE/AVX
 * 21 Sep 2014 » A bug story: testing your test code
 * 01 Oct 2014 » How to transpose a 16×16 byte matrix using SSE
 * 21 Oct 2014 » Bug story 2: Unrolling the 16×16 matrix transposition, or be
   careful with macros
 * 28 Oct 2014 » Macros, call by name, lambda and Jensen's device
 * 06 Nov 2016 » A bug story: data alignment on x86
 * 26 Sep 2019 » Making a char searcher in C

 * 02 May 2014 » De-multiplexing of E1 stream: converting to C
 * 07 May 2014 » From macros to templates
 * 12 May 2014 » The mystery of an unstable performance
 * 15 May 2014 » How to make C run as fast as Java
 * 18 May 2014 » Size does matter
 * 04 Jun 2014 » Fast E1 de-multiplexing in C using SSE/AVX
 * 21 Sep 2014 » A bug story: testing your test code
 * 01 Oct 2014 » How to transpose a 16×16 byte matrix using SSE
 * 21 Oct 2014 » Bug story 2: Unrolling the 16×16 matrix transposition, or be
   careful with macros
 * 28 Oct 2014 » Macros, call by name, lambda and Jensen's device
 * 24 Nov 2014 » How cache affects demultiplexing of E1
 * 24 Dec 2014 » More experiments with cache
 * 16 Oct 2016 » Searching in a constant set using conflict-free hashing
 * 18 Jul 2018 » Building a fast queue between C++ and Java
 * 17 Jan 2019 » To allocate or to pool?

 * 02 May 2014 » De-multiplexing of E1 stream: converting to C
 * 05 May 2014 » One handy C idiom: multi-statement macro

 * 02 May 2014 » De-multiplexing of E1 stream: converting to C
 * 07 May 2014 » From macros to templates

 * 05 May 2014 » One handy C idiom: multi-statement macro

 * 07 May 2014 » From macros to templates

 * 12 May 2014 » The mystery of an unstable performance
 * 15 May 2014 » How to make C run as fast as Java
 * 18 May 2014 » Size does matter
 * 04 Jun 2014 » Fast E1 de-multiplexing in C using SSE/AVX
 * 01 Oct 2014 » How to transpose a 16×16 byte matrix using SSE
 * 21 Oct 2014 » Bug story 2: Unrolling the 16×16 matrix transposition, or be
   careful with macros
 * 28 Oct 2014 » Macros, call by name, lambda and Jensen's device

 * 04 Jun 2014 » Fast E1 de-multiplexing in C using SSE/AVX
 * 01 Oct 2014 » How to transpose a 16×16 byte matrix using SSE
 * 21 Oct 2014 » Bug story 2: Unrolling the 16×16 matrix transposition, or be
   careful with macros

 * 04 Jun 2014 » Fast E1 de-multiplexing in C using SSE/AVX
 * 01 Oct 2014 » How to transpose a 16×16 byte matrix using SSE
 * 21 Oct 2014 » Bug story 2: Unrolling the 16×16 matrix transposition, or be
   careful with macros

 * 21 Sep 2014 » A bug story: testing your test code
 * 21 Oct 2014 » Bug story 2: Unrolling the 16×16 matrix transposition, or be
   careful with macros

 * 24 Nov 2014 » How cache affects demultiplexing of E1
 * 24 Dec 2014 » More experiments with cache

 * 19 Jan 2015 » On the benefits of stream buffering in Java
 * 01 Feb 2015 » Standard input, buffering and affinity mask

 * 19 Jan 2015 » On the benefits of stream buffering in Java

 * 19 Jan 2015 » On the benefits of stream buffering in Java
 * 01 Feb 2015 » Standard input, buffering and affinity mask

 * 01 Feb 2015 » Standard input, buffering and affinity mask

 * 01 Feb 2015 » Standard input, buffering and affinity mask

 * 01 Feb 2015 » Standard input, buffering and affinity mask

 * 24 Apr 2015 » Game of Life, hash tables and hash codes
 * 10 Sep 2015 » Hash functions: disassembling and measuring performance
 * 17 Sep 2015 » Optimising division-based hash functions
 * 12 Oct 2015 » The fun and the cost of refactoring
 * 20 Oct 2015 » More optimisations of division-based hash: Karatsuba's method
 * 28 Oct 2015 » Don't trust a micro-benchmark
 * 21 Nov 2015 » CRC32: intrinsic, Java or C with JNI?
 * 04 Dec 2015 » Optimising the hash-based Life
 * 14 Dec 2015 » Choosing the hash map's capacity
 * 22 Dec 2015 » Implementing Peano arithmetic
 * 10 Jan 2016 » Home-made binary numbers
 * 31 Jan 2016 » Home-made hash tables in Java
 * 21 Mar 2016 » Home-made hash tables in C++: a race against Java
 * 16 Oct 2016 » Searching in a constant set using conflict-free hashing
 * 07 Oct 2019 » Abnormal string hashing

 * 24 Apr 2015 » Game of Life, hash tables and hash codes
 * 10 Sep 2015 » Hash functions: disassembling and measuring performance
 * 17 Sep 2015 » Optimising division-based hash functions
 * 12 Oct 2015 » The fun and the cost of refactoring
 * 20 Oct 2015 » More optimisations of division-based hash: Karatsuba's method
 * 28 Oct 2015 » Don't trust a micro-benchmark
 * 21 Nov 2015 » CRC32: intrinsic, Java or C with JNI?
 * 04 Dec 2015 » Optimising the hash-based Life
 * 14 Dec 2015 » Choosing the hash map's capacity
 * 31 Jan 2016 » Home-made hash tables in Java
 * 21 Mar 2016 » Home-made hash tables in C++: a race against Java

 * 10 Sep 2015 » Hash functions: disassembling and measuring performance

 * 12 Oct 2015 » The fun and the cost of refactoring

 * 12 Oct 2015 » The fun and the cost of refactoring

 * 22 Dec 2015 » Implementing Peano arithmetic
 * 10 Jan 2016 » Home-made binary numbers

 * 16 Oct 2016 » Searching in a constant set using conflict-free hashing
 * 13 Apr 2019 » Searching for a better indexOf
 * 26 Sep 2019 » Making a char searcher in C

 * 16 Oct 2016 » Searching in a constant set using conflict-free hashing

 * 06 Nov 2016 » A bug story: data alignment on x86

 * 22 Mar 2017 » Statistical variables in Java: not quite legal but very fast

 * 23 Jul 2017 » The slow currentTimeMillis()
 * 18 Jul 2018 » Building a fast queue between C++ and Java
 * 17 Jan 2019 » To allocate or to pool?

 * 23 Jul 2017 » The slow currentTimeMillis()

 * 23 Jul 2017 » The slow currentTimeMillis()

 * 07 Oct 2019 » Abnormal string hashing
 * 26 Sep 2019 » Making a char searcher in C
 * 13 Apr 2019 » Searching for a better indexOf
 * 17 Jan 2019 » To allocate or to pool?
 * 18 Jul 2018 » Building a fast queue between C++ and Java
 * 23 Jul 2017 » The slow currentTimeMillis()
 * 22 Mar 2017 » Statistical variables in Java: not quite legal but very fast
 * 08 Dec 2016 » Turbo Boost and multi-threading performance
 * 06 Nov 2016 » A bug story: data alignment on x86
 * 16 Oct 2016 » Searching in a constant set using conflict-free hashing
 * 21 Mar 2016 » Home-made hash tables in C++: a race against Java
 * 31 Jan 2016 » Home-made hash tables in Java
 * 10 Jan 2016 » Home-made binary numbers
 * 22 Dec 2015 » Implementing Peano arithmetic
 * 14 Dec 2015 » Choosing the hash map's capacity
 * 04 Dec 2015 » Optimising the hash-based Life
 * 21 Nov 2015 » CRC32: intrinsic, Java or C with JNI?
 * 28 Oct 2015 » Don't trust a micro-benchmark
 * 20 Oct 2015 » More optimisations of division-based hash: Karatsuba's method
 * 12 Oct 2015 » The fun and the cost of refactoring
 * 17 Sep 2015 » Optimising division-based hash functions
 * 10 Sep 2015 » Hash functions: disassembling and measuring performance
 * 24 Apr 2015 » Game of Life, hash tables and hash codes
 * 01 Feb 2015 » Standard input, buffering and affinity mask
 * 19 Jan 2015 » On the benefits of stream buffering in Java
 * 24 Dec 2014 » More experiments with cache
 * 24 Nov 2014 » How cache affects demultiplexing of E1
 * 14 Nov 2014 » Lambdas and other callbacks in Java
 * 28 Oct 2014 » Macros, call by name, lambda and Jensen's device
 * 21 Oct 2014 » Bug story 2: Unrolling the 16×16 matrix transposition, or be
   careful with macros
 * 01 Oct 2014 » How to transpose a 16×16 byte matrix using SSE
 * 21 Sep 2014 » A bug story: testing your test code
 * 04 Jun 2014 » Fast E1 de-multiplexing in C using SSE/AVX
 * 18 May 2014 » Size does matter
 * 15 May 2014 » How to make C run as fast as Java
 * 12 May 2014 » The mystery of an unstable performance
 * 07 May 2014 » From macros to templates
 * 05 May 2014 » One handy C idiom: multi-statement macro
 * 02 May 2014 » De-multiplexing of E1 stream: converting to C
 * 15 Apr 2014 » De-multiplexing of E1 streams in Java

github.com/pzemtsov

RSS feed

@blog_pzemtsov