Try this:

    Eigen::MatrixXd d;                       // Matrix of doubles.
    Eigen::MatrixXf f = d.cast &lt;float&gt; ();   // Matrix of floats.

(This is a repeat of: https://stackoverflow.com/questions/6139699/how-to-correctly-read-an-interlocked-incremented-int-field but, after reading the answers and comments, I&#39;m still not sure of the right answer.)

There&#39;s some code that I don&#39;t own and can&#39;t change to use locks that increments an int counter (numberOfUpdates) in several different threads.  All calls use:

    Interlocked.Increment(ref numberOfUpdates);

I want to read numberOfUpdates in my code.  Now since this is an int, I know that it can&#39;t tear.  But what&#39;s the best way to ensure that I get the latest value possible?  It seems like my options are:

    int localNumberOfUpdates = Interlocked.CompareExchange(ref numberOfUpdates, 0, 0);

Or

    int localNumberOfUpdates = Thread.VolatileRead(numberOfUpdates);

Will both work (in the sense of delivering the latest value possible regardless of optimizations, re-orderings, caching, etc.)?  Is one preferred over the other?  Is there a third option that&#39;s better?


Reading an int that&#39;s updated by Interlocked on other threads

I have a game state in Python with about 1000 objects (planetary systems + stars + planets), and I need to copy it and apply a bunch of transformations to it when requested. However, at about 1 request/second, this is [taking up 24.63% of my runtime](https://i.imgur.com/nFxVO2k.png). How can I make it go fast? Note that copying less is not an option, since the transforms touch just about everything.

**EDIT**: got it down to 8% with judicious implementation of `__deepcopy__` on things. Still, not good enough. (Good enough is 1% or less, I plan on throwing many more things at this.) `timeit` says 41.8ms per `deepcopy()`.

deepcopy() is extremely slow

I am using [Eigen][1] on a C++ program.

I wonder if there is a way to cast from `Eigen::MatrixXd` to `Eigen::MatrixXf`.  
`static_cast &lt;Eigen::MatrixXf&gt;` doesn&#39;t seem to work and neither `A.cast&lt;MatrixXf&gt;` (this is the cast method from Eigen).

Any solution for this type of cast?

  [1]: http://eigen.tuxfamily.org/index.php?title=Main_Page

Cast Eigen::MatrixXd to Eigen::MatrixXf

I am using <a href="http://eigen.tuxfamily.org/index.php?title=Main_Page" target="_blank" rel="noopener noreferrer">Eigen</a> on a C++ program.
I wonder if there is a way to cast from <code>Eigen::MatrixXd</code> to <code>Eigen::MatrixXf</code>. 
<code>static_cast &#x3C;Eigen::MatrixXf></code> doesn't seem to work and neither <code>A.cast&#x3C;MatrixXf></code> (this is the cast method from Eigen).
Any solution for this type of cast?

Which is best way to pause the console in C++ programs?
    
 0. using `cin.get()`
 0. or using `system(&quot;pause&quot;)`
 0. or using C functions like `getch()` or `getchar()`?

Is it true that use of `system(&quot;pause&quot;)` leads to non portable code and can&#39;t work in UNIX?
    
Is cin.get() is better to use to pause console? 

Pause Console in C++ program

Suppose I have the following:

    #include &lt;memory&gt;
    struct A { int x; };

    class B {
      B(int x, std::unique_ptr&lt;A&gt; a);
    };
    
    class C : public B {
      C(std::unique_ptr&lt;A&gt; a) : B(a-&gt;x, std::move(a)) {}
    };



If I understand the C++ rules about &quot;unspecified order of function parameters&quot; correctly, this code is unsafe. If the second argument to `B`&#39;s constructor is constructed first using the move constructor, then `a` now contains a `nullptr` and the expression `a-&gt;x` will trigger undefined behavior (likely segfault). If the first argument is constructed first, then everything will work as intended.

If this were a normal function call, we could just create a temporary:

    auto x = a-&gt;x
    B b{x, std::move(a)};

But in the class initialization list we don&#39;t have the freedom to create temporary variables.

Suppose I cannot change `B`, is there any possible way to accomplish the above? Namely dereferencing and moving a `unique_ptr` in the same function call expression without creating a temporary?

What if you could change `B`&#39;s constructor but not add new methods such as `setX(int)`? Would that help?

Thank you


Move semantics and function order evaluation

I wrote a little benchmark to compare the performance of different interpreters/compilers for Python, Ruby, JavaScript and C++.
As expected, it turns out that (optimized) C++ beats the scripting languages, but the factor by which it does so is incredibly high.

The results are:

    sven@jet:~/tmp/js$ time node bla.js              # * JavaScript with node *
    0
    
    real	0m1.222s
    user	0m1.190s
    sys	0m0.015s
    sven@jet:~/tmp/js$ time ruby foo.rb              # * Ruby *
    0
    
    real	0m52.428s
    user	0m52.395s
    sys	0m0.028s
    sven@jet:~/tmp/js$ time python blub.py           # * Python with CPython *
    0

    real	1m16.480s
    user	1m16.371s
    sys	0m0.080s

    sven@jet:~/tmp/js$ time pypy blub.py             # * Python with PyPy *
    0

    real	0m4.707s
    user	0m4.579s
    sys	0m0.028s

    sven@jet:~/tmp/js$ time ./cpp_non_optimized 1000 1000000 # * C++ with -O0 (gcc) *
    0
    
    real	0m1.702s
    user	0m1.699s
    sys	0m0.002s
    sven@jet:~/tmp/js$ time ./cpp_optimized 1000 1000000     # * C++ with -O3 (gcc) *
    0
    
    real	0m0.003s # (!!!) &lt;---------------------------------- WHY?
    user	0m0.002s
    sys	0m0.002s

I am wondering if anybody can provide an explanation why the optimized C++ code is over three orders of magnitude faster than everything else.

The C++ benchmark uses command-line parameters in order to prevent pre-computing the result at compile time.


Below, I placed the source codes for the different language benchmarks, which should be semantically equivalent.
Also, I provided the assembly code for the optimized C++ compiler output (using gcc).
When looking at the optimized assembly, it seems that the compiler merged the two loops in the benchmark to a single one, but nevertheless, there IS still a loop!

**JavaScript:**

    var s = 0;
    var outer = 1000;
    var inner = 1000000;
    
    for (var i = 0; i &lt; outer; ++i) {
    	for (var j = 0; j &lt; inner; ++j) {
    		++s;
    	}
    	s -= inner;
    }
    console.log(s);

**Python:**

    s = 0
    outer = 1000
    inner = 1000000
    
    for _ in xrange(outer):
        for _ in xrange(inner):
            s += 1
        s -= inner
    print s

**Ruby:**

    s = 0
    outer = 1000
    inner = 1000000
    
    outer_end = outer - 1
    inner_end = inner - 1
    
    for i in 0..outer_end
      for j in 0..inner_end
        s = s + 1
      end
      s = s - inner
    end
    puts s

**C++:**

    #include &lt;iostream&gt;
    #include &lt;cstdlib&gt;
    #include &lt;cstdint&gt;
    
    int main(int argc, char* argv[]) {
      uint32_t s = 0;
      uint32_t outer = atoi(argv[1]);
      uint32_t inner = atoi(argv[2]);
      for (uint32_t i = 0; i &lt; outer; ++i) {
        for (uint32_t j = 0; j &lt; inner; ++j)
          ++s;
        s -= inner;
      }
      std::cout &lt;&lt; s &lt;&lt; std::endl;
      return 0;
    }

**Assembly (when compiling the above C++ code with gcc -S -O3 -std=c++0x):**

    	.file	&quot;bar.cpp&quot;
    	.section	.text.startup,&quot;ax&quot;,@progbits
    	.p2align 4,,15
    	.globl	main
    	.type	main, @function
    main:
    .LFB1266:
    	.cfi_startproc
    	pushq	%r12
    	.cfi_def_cfa_offset 16
    	.cfi_offset 12, -16
    	movl	$10, %edx
    	movq	%rsi, %r12
    	pushq	%rbp
    	.cfi_def_cfa_offset 24
    	.cfi_offset 6, -24
    	pushq	%rbx
    	.cfi_def_cfa_offset 32
    	.cfi_offset 3, -32
    	movq	8(%rsi), %rdi
    	xorl	%esi, %esi
    	call	strtol
    	movq	16(%r12), %rdi
    	movq	%rax, %rbp
    	xorl	%esi, %esi
    	movl	$10, %edx
    	call	strtol
    	testl	%ebp, %ebp
    	je	.L6
    	movl	%ebp, %ebx
    	xorl	%eax, %eax
    	xorl	%edx, %edx
    	.p2align 4,,10
    	.p2align 3
    .L3:                             # &lt;--- Here is the loop
    	addl	$1, %eax             # &lt;---
    	cmpl	%eax, %ebx           # &lt;---
    	ja	.L3                      # &lt;---
    .L2:
    	movl	%edx, %esi
    	movl	$_ZSt4cout, %edi
    	call	_ZNSo9_M_insertImEERSoT_
    	movq	%rax, %rdi
    	call	_ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_
    	popq	%rbx
    	.cfi_remember_state
    	.cfi_def_cfa_offset 24
    	popq	%rbp
    	.cfi_def_cfa_offset 16
    	xorl	%eax, %eax
    	popq	%r12
    	.cfi_def_cfa_offset 8
    	ret
    .L6:
    	.cfi_restore_state
    	xorl	%edx, %edx
    	jmp	.L2
    	.cfi_endproc
    .LFE1266:
    	.size	main, .-main
    	.p2align 4,,15
    	.type	_GLOBAL__sub_I_main, @function
    _GLOBAL__sub_I_main:
    .LFB1420:
    	.cfi_startproc
    	subq	$8, %rsp
    	.cfi_def_cfa_offset 16
    	movl	$_ZStL8__ioinit, %edi
    	call	_ZNSt8ios_base4InitC1Ev
    	movl	$__dso_handle, %edx
    	movl	$_ZStL8__ioinit, %esi
    	movl	$_ZNSt8ios_base4InitD1Ev, %edi
    	addq	$8, %rsp
    	.cfi_def_cfa_offset 8
    	jmp	__cxa_atexit
    	.cfi_endproc
    .LFE1420:
    	.size	_GLOBAL__sub_I_main, .-_GLOBAL__sub_I_main
    	.section	.init_array,&quot;aw&quot;
    	.align 8
    	.quad	_GLOBAL__sub_I_main
    	.local	_ZStL8__ioinit
    	.comm	_ZStL8__ioinit,1,1
    	.hidden	__dso_handle
    	.ident	&quot;GCC: (Ubuntu 4.8.2-19ubuntu1) 4.8.2&quot;
    	.section	.note.GNU-stack,&quot;&quot;,@progbits



Why is this C++ program so incredibly fast?

The situation:

I have an application written in C which is resource intensive, and designed to be portable. I want to allow the compiler to select the fastest int size for the architecture, provided it is at least 32 bits.

Is it possible to select a size of &quot;at least&quot; 32 bits, or will the compiler optimize these kinds of things form me automatically?

How do I ask for &quot;at least&quot; a size of an int in C

I have always heard that C++ was way more efficient than Java (and that is why most games are developed in C++).

I wrote a small algorithm to solve the &quot;Eight queens puzzle&quot; in both Java and C++, using the exact same algorithm, and then started to raise the number or squares.
When reaching checkboards of 20*20 or even 22*22, it appears Java is much more effective (3 seconds vs 66 seconds for C++).

I have no idea why, but I am pretty beginning with C++, so it is possible I made some huge performance mistakes, so I will gladly accept any information that would help me understand what is happening.

Below is the code I use in Java:


    import java.awt.Point;
    import java.util.ArrayList;
    import java.util.List;

    public class HuitDames {

        /**
         * La liste des coordnn&#233;es des dames.
         */
        private static List&lt;Point&gt; positions = new ArrayList&lt;&gt;();

        /**
         * Largeur de la grille.
         */
        private static final int LARGEUR_GRILLE = 22;


        /**
         * @param args the command line arguments
         */
        public static void main(String[] args) {
            int i = 1;
            placerDame(i);
            for (Point point : positions) {
                System.out.println(&quot;(&quot; + point.x + &quot;; &quot; + point.y + &quot;)&quot;);
            }
        }

        /**
         * Place une dame et return true si la position est bonne.
         * @param i le num&#233;ro de la dame.
         * @return si la position est bonne.
         */
        private static boolean placerDame(int i) {

            boolean bonnePosition = false;
            for (int j = 1; j &lt;= LARGEUR_GRILLE &amp;&amp; bonnePosition == false; j++) {
                Point emplacement = new Point(i, j);
                positions.add(emplacement);
                if (verifierPrise(emplacement) &amp;&amp; (i == LARGEUR_GRILLE || placerDame(i + 1))) {
                    bonnePosition = true;
                }
                else {
                    positions.remove(i - 1);
                }
            }

            return bonnePosition;
        }

        /**
         * V&#233;rifie que la nouvelle position n&#39;est pas en prise avec une position d&#233;j&#224; pr&#233;sente.
         * @param position la position de la nouvelle dame.
         * @return Si la position convient par rapport aux positions des autres dames.
         */
        private static boolean verifierPrise(Point position) {
            boolean nonPrise = true;
            for (Point point : positions) {
                if (!point.equals(position)) {
                    // Cas o&#249; sur la m&#234;me colonne.
                    if (position.y == point.y) {
                        nonPrise = false;
                    }
                    // Cas o&#249; sur m&#234;me diagonale.
                    if (Math.abs(position.y - point.y) == Math.abs(position.x - point.x)) {
                        nonPrise = false;
                    }
                }
            }

            return nonPrise;
        }
    }

And below is the code in C++:

    #include &lt;iostream&gt;
    #include &lt;list&gt;
    #include &lt;math.h&gt;
    #include &lt;stdlib.h&gt;

    using namespace std;


    // Class to represent points.
    class Point {

        private:
            double xval, yval;

        public:
            // Constructor uses default arguments to allow calling with zero, one,
            // or two values.
            Point(double x = 0.0, double y = 0.0) {
                    xval = x;
                    yval = y;
            }

            // Extractors.
            double x() { return xval; }
            double y() { return yval; }
    };

    #define LARGEUR_GRILLE 22
    list&lt;Point&gt; positions;


    bool verifierNonPrise(Point emplacement) {
        bool nonPrise = true;
        for (list&lt;Point&gt;::iterator it = positions.begin(); it!= positions.end(); it++) {
            if (it-&gt;x() != emplacement.x()) {
                if (it-&gt;y() == emplacement.y()) {
                    nonPrise = false;
                }
                if (abs(it-&gt;y() - emplacement.y()) == abs(it-&gt;x() - emplacement.x())) {
                    nonPrise = false;
                }
            }
        }

        return nonPrise;
    }

    bool placerDame(int i) {
        bool bonnePosition = false;
        for (int j = 1; j &lt;= LARGEUR_GRILLE &amp;&amp; !bonnePosition; j++) {
            Point emplacement(i,j);
            positions.push_back(emplacement);
            if (verifierNonPrise(emplacement) &amp;&amp; (i == LARGEUR_GRILLE || placerDame(i + 1))) {
                bonnePosition = true;
            }
            else {
                positions.pop_back();
            }
        }

        return bonnePosition;
    }

    int main()
    {
        int i = 1;
        placerDame(i);
        for (list&lt;Point&gt;::iterator it = positions.begin(); it!= positions.end(); it++) {
            cout &lt;&lt; &quot;(&quot; &lt;&lt; it-&gt;x() &lt;&lt; &quot;; &quot; &lt;&lt; it-&gt;y() &lt;&lt; &quot;)&quot; &lt;&lt; endl;
        }
        return 0;
    }


Content Type	Original Author	Original Content on Stackoverflow
Question	Sapiens	View Question on Stackoverflow
Solution 1 - C++	Gluttton	View Answer on Stackoverflow

Cast Eigen::MatrixXd to Eigen::MatrixXf

C++ Problem Overview

C++ Solutions

Solution 1 - C++

deepcopy() is extremely slow

Reading an int that's updated by Interlocked on other threads

Attributions