`0.0039215689` is approximately equal to `1/255`.

Seeing that this is OpenGL, performance is probably important. So it&#39;s probably safe to guess that this was done for performance reasons.

Multiplying by the reciprocal is faster than repeatedly dividing by 255.


----------


**Side Note:**

If you&#39;re wondering why such a micro-optimization isn&#39;t left to the compiler, it&#39;s because it is an unsafe floating-point optimization. In other words:

    x / 255  !=  x * (1. / 255)

due to floating-point round-off errors.


So while modern compilers may be smart enough to do this optimization, they are not allowed to do it unless you explicitly tell them to via a compiler flag.

**Related:** https://stackoverflow.com/q/6430448/922184

This multiplication by `0.0039215689f` converts an integer valued color intensity in the range 0 to 255 to a real valued color intensity in the range 0 to 1.

As Ilmari Karonen points out, even if this is an optimisation it&#39;s a rather badly expressed one. It would be so much clearer to multiply by `(1.0f/255)`. 

I know how to generate a random number within a range in Python.

    random.randint(numLow, numHigh)

And I know I can put this in a loop to generate n amount of these numbers

    for x in range (0, n):
        listOfNumbers.append(random.randint(numLow, numHigh))

However, I need to make sure each number in that list is unique. Other than a load of conditional statements, is there a straightforward way of generating n number of unique random numbers?

The important thing is that each number in the list is different to the others..

So

   [12, 5, 6, 1] = good

But

   [12, 5, 5, 1] = bad, because the number 5 occurs twice.



Generate &#39;n&#39; unique random numbers within a range

I would like to read a resource from within my jar like so:

    File file;
    file = new File(getClass().getResource(&quot;/file.txt&quot;).toURI());
    BufferedReader reader = new BufferedReader(new FileReader(file));

    //Read the file


 and it works fine when running it in Eclipse, but if I export it to a jar, and then run it, there is an IllegalArgumentException: 

    Exception in thread &quot;Thread-2&quot;
    java.lang.IllegalArgumentException: URI is not hierarchical

and I really don&#39;t know why but with some testing I found if I change

    file = new File(getClass().getResource(&quot;/file.txt&quot;).toURI());
to

    file = new File(getClass().getResource(&quot;/folder/file.txt&quot;).toURI());

then it works the opposite (it works in jar but not eclipse).

I&#39;m using Eclipse and the folder with my file is in a class folder.


Reading a resource file from within jar

I keep seeing this constant pop up in various graphics header files

    0.0039215689

It seems to have something to do with color maybe?

Here is the first [hit on Google](http://ozmav.googlecode.com/svn-history/r178/trunk/badrdp/rdp.c):

    void RDP_G_SETFOGCOLOR(void)
    {
    	Gfx.FogColor.R = _SHIFTR(w1, 24, 8) * 0.0039215689f;
    	Gfx.FogColor.G = _SHIFTR(w1, 16, 8) * 0.0039215689f;
    	Gfx.FogColor.B = _SHIFTR(w1, 8, 8) * 0.0039215689f;
    	Gfx.FogColor.A = _SHIFTR(w1, 0, 8) * 0.0039215689f;
    }
    
    void RDP_G_SETBLENDCOLOR(void)
    {
    	Gfx.BlendColor.R = _SHIFTR(w1, 24, 8) * 0.0039215689f;
    	Gfx.BlendColor.G = _SHIFTR(w1, 16, 8) * 0.0039215689f;
    	Gfx.BlendColor.B = _SHIFTR(w1, 8, 8) * 0.0039215689f;
    	Gfx.BlendColor.A = _SHIFTR(w1, 0, 8) * 0.0039215689f;
    
    	if(OpenGL.Ext_FragmentProgram &amp;&amp; (System.Options &amp; BRDP_COMBINER)) {
    		glProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, 2, Gfx.BlendColor.R, Gfx.BlendColor.G, Gfx.BlendColor.B, Gfx.BlendColor.A);
    	}
    }

    //...more like this

What does this number represent? Why does no one seem to declare it as a const?

I couldn&#39;t find anything on Google that explained it.

What does the constant 0.0039215689 represent?

I keep seeing this constant pop up in various graphics header files
<pre><code class="hljs">0.0039215689
</code></pre>
It seems to have something to do with color maybe?
Here is the first <a href="http://ozmav.googlecode.com/svn-history/r178/trunk/badrdp/rdp.c" target="_blank" rel="noopener noreferrer">hit on Google</a>:
<pre><code class="hljs language-ini">void RDP_G_SETFOGCOLOR(void)
{
	Gfx.FogColor.R = _SHIFTR(w1, 24, 8) * 0.0039215689f;
	Gfx.FogColor.G = _SHIFTR(w1, 16, 8) * 0.0039215689f;
	Gfx.FogColor.B = _SHIFTR(w1, 8, 8) * 0.0039215689f;
	Gfx.FogColor.A = _SHIFTR(w1, 0, 8) * 0.0039215689f;
}

void RDP_G_SETBLENDCOLOR(void)
{
	Gfx.BlendColor.R = _SHIFTR(w1, 24, 8) * 0.0039215689f;
	Gfx.BlendColor.G = _SHIFTR(w1, 16, 8) * 0.0039215689f;
	Gfx.BlendColor.B = _SHIFTR(w1, 8, 8) * 0.0039215689f;
	Gfx.BlendColor.A = _SHIFTR(w1, 0, 8) * 0.0039215689f;

	if(OpenGL.Ext_FragmentProgram &#x26;&#x26; (System.Options &#x26; BRDP_COMBINER)) {
		glProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, 2, Gfx.BlendColor.R, Gfx.BlendColor.G, Gfx.BlendColor.B, Gfx.BlendColor.A);
	}
}

//...more like this
</code></pre>
What does this number represent? Why does no one seem to declare it as a const?
I couldn't find anything on Google that explained it.

I need to write an SPI Linux character device driver for omap4 from scratch.
I know some basics of writing device drivers. But, I don&#39;t know how to start writing platform specific device driver from scratch.

I&#39;ve written some basic char drivers, and I thought writing SPI device driver would be similar to it. Char drivers have a structure `file_operations` which contains the functions implemented in the driver.

    struct file_operations Fops = {
    	.read = device_read,
    	.write = device_write,
    	.ioctl = device_ioctl,
    	.open = device_open,
    	.release = device_release,	/* a.k.a. close */
    };

Now, I am going through [spi-omap2-mcspi.c][1] code as a reference to get an idea to start developing SPI driver from scratch.

But, I don&#39;t see functions such as open, read, write etc.
Don&#39;t know from where the program starts.


  [1]: http://lxr.free-electrons.com/source/drivers/spi/spi-omap2-mcspi.c

How to write a simple Linux device driver?

This is what I found during my learning period:

    #include&lt;iostream&gt;
    using namespace std;
    int dis(char a[1])
    {
        int length = strlen(a);
        char c = a[2];
        return length;
    }
    int main()
    {
        char b[4] = &quot;abc&quot;;
        int c = dis(b);
        cout &lt;&lt; c;
        return 0;
    }  

So in the variable `int dis(char a[1])` , the `[1]` seems to do nothing and doesn&#39;t work at  
all, because I can use `a[2]`.  Just like `int a[]` or `char *a`. I know the array name is a pointer and how to convey an array, so my puzzle is not about this part. 

What I want to know is why compilers allow this behavior (`int a[1]`). Or does it have other meanings that I don&#39;t know about?

Why do C and C++ compilers allow array lengths in function signatures when they&#39;re never enforced?

We have recently purchased some new servers and are experiencing poor memcpy performance. The memcpy performance is 3x slower on the servers compared to our laptops.

**Server Specs**

 - Chassis and Mobo: SUPER MICRO 1027GR-TRF
 - CPU: 2x Intel Xeon E5-2680 @ 2.70 Ghz
 - Memory: 8x 16GB DDR3 1600MHz

Edit: I am also testing on another server with slightly higher specs and seeing the same results as the above server

**Server 2 Specs**

 - Chassis and Mobo: SUPER MICRO 10227GR-TRFT
 - CPU: 2x Intel Xeon E5-2650 v2 @ 2.6 Ghz
 - Memory: 8x 16GB DDR3 1866MHz

**Laptop Specs**

 - Chassis: Lenovo W530
 - CPU: 1x Intel Core i7 i7-3720QM @ 2.6Ghz
 - Memory: 4x 4GB DDR3 1600MHz

**Operating System**

    $ cat /etc/redhat-release
    Scientific Linux release 6.5 (Carbon) 
    $ uname -a                      
    Linux r113 2.6.32-431.1.2.el6.x86_64 #1 SMP Thu Dec 12 13:59:19 CST 2013 x86_64 x86_64 x86_64 GNU/Linux

**Compiler (on all systems)**

    $ gcc --version
    gcc (GCC) 4.6.1

Also tested with gcc 4.8.2 based on a suggestion from @stefan. There was no performance difference between compilers.


**Test Code**
The test code below is a canned test to duplicate the problem i am seeing in our production code. I know this benchmark is simplistic but it was able to exploit and identify our problem. The code creates two 1GB buffers and memcpys between them, timing the memcpy call. You can specify alternate buffer sizes on the command line using: ./big_memcpy_test [SIZE_BYTES]

    #include &lt;chrono&gt;
    #include &lt;cstring&gt;
    #include &lt;iostream&gt;
    #include &lt;cstdint&gt;
    
    class Timer
    {
     public:
      Timer()
          : mStart(),
            mStop()
      {
        update();
      }
    
      void update()
      {
        mStart = std::chrono::high_resolution_clock::now();
        mStop  = mStart;
      }
    
      double elapsedMs()
      {
        mStop = std::chrono::high_resolution_clock::now();
        std::chrono::milliseconds elapsed_ms =
            std::chrono::duration_cast&lt;std::chrono::milliseconds&gt;(mStop - mStart);
        return elapsed_ms.count();
      }
    
     private:
      std::chrono::high_resolution_clock::time_point mStart;
      std::chrono::high_resolution_clock::time_point mStop;
    };
    
    std::string formatBytes(std::uint64_t bytes)
    {
      static const int num_suffix = 5;
      static const char* suffix[num_suffix] = { &quot;B&quot;, &quot;KB&quot;, &quot;MB&quot;, &quot;GB&quot;, &quot;TB&quot; };
      double dbl_s_byte = bytes;
      int i = 0;
      for (; (int)(bytes / 1024.) &gt; 0 &amp;&amp; i &lt; num_suffix;
           ++i, bytes /= 1024.)
      {
        dbl_s_byte = bytes / 1024.0;
      }
    
      const int buf_len = 64;
      char buf[buf_len];
    
      // use snprintf so there is no buffer overrun
      int res = snprintf(buf, buf_len,&quot;%0.2f%s&quot;, dbl_s_byte, suffix[i]);
      
      // snprintf returns number of characters that would have been written if n had
      //       been sufficiently large, not counting the terminating null character.
      //       if an encoding error occurs, a negative number is returned.
      if (res &gt;= 0)
      {
        return std::string(buf);
      }
      return std::string();
    }
    
    void doMemmove(void* pDest, const void* pSource, std::size_t sizeBytes)
    {
      memmove(pDest, pSource, sizeBytes);
    }
    
    int main(int argc, char* argv[])
    {
      std::uint64_t SIZE_BYTES = 1073741824; // 1GB
      
      if (argc &gt; 1)
      {
        SIZE_BYTES = std::stoull(argv[1]);
        std::cout &lt;&lt; &quot;Using buffer size from command line: &quot; &lt;&lt; formatBytes(SIZE_BYTES)
                  &lt;&lt; std::endl;
      }
      else
      {
        std::cout &lt;&lt; &quot;To specify a custom buffer size: big_memcpy_test [SIZE_BYTES] \n&quot;
                  &lt;&lt; &quot;Using built in buffer size: &quot; &lt;&lt; formatBytes(SIZE_BYTES)
                  &lt;&lt; std::endl;
      }
      
    
      // big array to use for testing
      char* p_big_array = NULL;
    
      /////////////
      // malloc 
      {
        Timer timer;
      
        p_big_array = (char*)malloc(SIZE_BYTES * sizeof(char));
        if (p_big_array == NULL)
        {
          std::cerr &lt;&lt; &quot;ERROR: malloc of &quot; &lt;&lt; SIZE_BYTES &lt;&lt; &quot; returned NULL!&quot;
                    &lt;&lt; std::endl;
          return 1;
        }
        
        std::cout &lt;&lt; &quot;malloc for &quot; &lt;&lt; formatBytes(SIZE_BYTES) &lt;&lt; &quot; took &quot;
                  &lt;&lt; timer.elapsedMs() &lt;&lt; &quot;ms&quot;
                  &lt;&lt; std::endl;
      }
      
      /////////////
      // memset
      {
        Timer timer;
    
        // set all data in p_big_array to 0
        memset(p_big_array, 0xF, SIZE_BYTES * sizeof(char));
    
        double elapsed_ms = timer.elapsedMs();
        std::cout &lt;&lt; &quot;memset for &quot; &lt;&lt; formatBytes(SIZE_BYTES) &lt;&lt; &quot; took &quot;
                  &lt;&lt; elapsed_ms &lt;&lt; &quot;ms &quot;
                  &lt;&lt; &quot;(&quot; &lt;&lt; formatBytes(SIZE_BYTES / (elapsed_ms / 1.0e3)) &lt;&lt; &quot; bytes/sec)&quot;
                  &lt;&lt; std::endl;
      }
    
      /////////////
      // memcpy 
      {
        char* p_dest_array = (char*)malloc(SIZE_BYTES);
        if (p_dest_array == NULL)
        {
          std::cerr &lt;&lt; &quot;ERROR: malloc of &quot; &lt;&lt; SIZE_BYTES &lt;&lt; &quot; for memcpy test&quot;
                    &lt;&lt; &quot; returned NULL!&quot;
                    &lt;&lt; std::endl;
          return 1;
        }
        memset(p_dest_array, 0xF, SIZE_BYTES * sizeof(char));
    
        // time only the memcpy FROM p_big_array TO p_dest_array
        Timer timer;
    
        memcpy(p_dest_array, p_big_array, SIZE_BYTES * sizeof(char));
        
        double elapsed_ms = timer.elapsedMs();
        std::cout &lt;&lt; &quot;memcpy for &quot; &lt;&lt; formatBytes(SIZE_BYTES) &lt;&lt; &quot; took &quot;
                  &lt;&lt; elapsed_ms &lt;&lt; &quot;ms &quot;
                  &lt;&lt; &quot;(&quot; &lt;&lt; formatBytes(SIZE_BYTES / (elapsed_ms / 1.0e3)) &lt;&lt; &quot; bytes/sec)&quot;
                  &lt;&lt; std::endl;
    
        // cleanup p_dest_array
        free(p_dest_array);
        p_dest_array = NULL;
      }
    
      /////////////
      // memmove
      {
        char* p_dest_array = (char*)malloc(SIZE_BYTES);
        if (p_dest_array == NULL)
        {
          std::cerr &lt;&lt; &quot;ERROR: malloc of &quot; &lt;&lt; SIZE_BYTES &lt;&lt; &quot; for memmove test&quot;
                    &lt;&lt; &quot; returned NULL!&quot;
                    &lt;&lt; std::endl;
          return 1;
        }
        memset(p_dest_array, 0xF, SIZE_BYTES * sizeof(char));
    
        // time only the memmove FROM p_big_array TO p_dest_array
        Timer timer;
    
        // memmove(p_dest_array, p_big_array, SIZE_BYTES * sizeof(char));
        doMemmove(p_dest_array, p_big_array, SIZE_BYTES * sizeof(char));
        
        double elapsed_ms = timer.elapsedMs();
        std::cout &lt;&lt; &quot;memmove for &quot; &lt;&lt; formatBytes(SIZE_BYTES) &lt;&lt; &quot; took &quot;
                  &lt;&lt; elapsed_ms &lt;&lt; &quot;ms &quot;
                  &lt;&lt; &quot;(&quot; &lt;&lt; formatBytes(SIZE_BYTES / (elapsed_ms / 1.0e3)) &lt;&lt; &quot; bytes/sec)&quot;
                  &lt;&lt; std::endl;
    
        // cleanup p_dest_array
        free(p_dest_array);
        p_dest_array = NULL;
      }
    
    
      // cleanup
      free(p_big_array);
      p_big_array = NULL;
      
      return 0;
    }


**CMake File to Build**

    project(big_memcpy_test)
    cmake_minimum_required(VERSION 2.4.0)
    
    include_directories(${CMAKE_CURRENT_SOURCE_DIR})
    
    # create verbose makefiles that show each command line as it is issued
    set( CMAKE_VERBOSE_MAKEFILE ON CACHE BOOL &quot;Verbose&quot; FORCE )
    # release mode
    set( CMAKE_BUILD_TYPE Release )
    # grab in CXXFLAGS environment variable and append C++11 and -Wall options
    set( CMAKE_CXX_FLAGS &quot;${CMAKE_CXX_FLAGS} -std=c++0x -Wall -march=native -mtune=native&quot; )
    message( INFO &quot;CMAKE_CXX_FLAGS = ${CMAKE_CXX_FLAGS}&quot; )
    
    # sources to build
    set(big_memcpy_test_SRCS
      main.cpp
    )
    
    # create an executable file named &quot;big_memcpy_test&quot; from
    # the source files in the variable &quot;big_memcpy_test_SRCS&quot;.
    add_executable(big_memcpy_test ${big_memcpy_test_SRCS})


**Test Results**

    Buffer Size: 1GB | malloc (ms) | memset (ms) | memcpy (ms) | NUMA nodes (numactl --hardware)
    ---------------------------------------------------------------------------------------------
    Laptop 1         | 0           | 127         | 113         | 1
    Laptop 2         | 0           | 180         | 120         | 1
    Server 1         | 0           | 306         | 301         | 2
    Server 2         | 0           | 352         | 325         | 2

As you can see the memcpys and memsets on our servers is much slower than the memcpys and memsets on our laptops.

**Varying buffer sizes**

I have tried buffers from 100MB to 5GB all with similar results (servers slower than laptop)


**NUMA Affinity**

I read about people having performance issues with NUMA so i tried setting CPU and memory affinity using numactl but the results remained the same.

Server NUMA Hardware

    $ numactl --hardware                                                            
    available: 2 nodes (0-1)                                                                     
    node 0 cpus: 0 1 2 3 4 5 6 7 16 17 18 19 20 21 22 23                                         
    node 0 size: 65501 MB                                                                        
    node 0 free: 62608 MB                                                                        
    node 1 cpus: 8 9 10 11 12 13 14 15 24 25 26 27 28 29 30 31                                   
    node 1 size: 65536 MB                                                                        
    node 1 free: 63837 MB                                                                        
    node distances:                                                                              
    node   0   1                                                                                 
      0:  10  21                                                                                 
      1:  21  10 


Laptop NUMA Hardware

    $ numactl --hardware
    available: 1 nodes (0)
    node 0 cpus: 0 1 2 3 4 5 6 7
    node 0 size: 16018 MB
    node 0 free: 6622 MB
    node distances:
    node   0 
      0:  10

Setting NUMA Affinity

    $ numactl --cpunodebind=0 --membind=0 ./big_memcpy_test


Any help resolving this is greatly appreciated.

**Edit: GCC Options**

Based on comments i have tried compiling with different GCC options:

Compiling with -march and -mtune set to native

    g++ -std=c++0x -Wall -march=native -mtune=native -O3 -DNDEBUG -o big_memcpy_test main.cpp 

Result: Exact same performance (no improvement)

Compiling with -O2 instead of -O3

    g++ -std=c++0x -Wall -march=native -mtune=native -O2 -DNDEBUG -o big_memcpy_test main.cpp

Result: Exact same performance (no improvement)

**Edit: Changed memset to write 0xF instead of 0 to avoid NULL page (@SteveCox)**

No improvement when memsetting with a value other than 0 (used 0xF in this case).

**Edit: Cachebench results**

In order to rule out that my test program is too simplistic i downloaded a real benchmarking program LLCacheBench (http://icl.cs.utk.edu/projects/llcbench/cachebench.html)

I built the benchmark on each machine separately to avoid architecture issues. Below are my results.

![laptop vs server memcpy performance][1]

Notice the VERY large difference is performance on the larger buffer sizes. The last size tested (16777216) performed at 18849.29 MB/sec on the laptop and 6710.40 on the server. That&#39;s about a 3x difference in performance. You can also notice that the performance dropoff of the server is much steeper than on the laptop.

**Edit: memmove() is 2x FASTER than memcpy() on the server**

Based on some experimentation i have tried using memmove() instead of memcpy() in my test case and have found a 2x improvement on the server. Memmove() on the laptop runs slower than memcpy() but oddly enough runs at the same speed as the memmove() on the server. This begs the question, why is memcpy so slow?

Updated Code to test memmove along with memcpy. I had to wrap the memmove() inside a function because if i left it inline GCC optimized it and performed the exact same as memcpy() (i assume gcc optimized it to memcpy because it knew the locations didn&#39;t overlap).

Updated Results

    Buffer Size: 1GB | malloc (ms) | memset (ms) | memcpy (ms) | memmove() | NUMA nodes (numactl --hardware)
    ---------------------------------------------------------------------------------------------------------
    Laptop 1         | 0           | 127         | 113         | 161       | 1
    Laptop 2         | 0           | 180         | 120         | 160       | 1
    Server 1         | 0           | 306         | 301         | 159       | 2
    Server 2         | 0           | 352         | 325         | 159       | 2

**Edit: Naive Memcpy**

Based on suggestion from @Salgar i have implemented my own naive memcpy function and tested it.

Naive Memcpy Source

    void naiveMemcpy(void* pDest, const void* pSource, std::size_t sizeBytes)
    {
      char* p_dest = (char*)pDest;
      const char* p_source = (const char*)pSource;
      for (std::size_t i = 0; i &lt; sizeBytes; ++i)
      {
        *p_dest++ = *p_source++;
      }
    }

Naive Memcpy Results Compared to memcpy()

    Buffer Size: 1GB | memcpy (ms) | memmove(ms) | naiveMemcpy()
    ------------------------------------------------------------
    Laptop 1         | 113         | 161         | 160
    Server 1         | 301         | 159         | 159
    Server 2         | 325         | 159         | 159

**Edit: Assembly Output**

Simple memcpy source

    #include &lt;cstring&gt;
    #include &lt;cstdlib&gt;
    
    int main(int argc, char* argv[])
    {
      size_t SIZE_BYTES = 1073741824; // 1GB
      
      char* p_big_array  = (char*)malloc(SIZE_BYTES * sizeof(char));
      char* p_dest_array = (char*)malloc(SIZE_BYTES * sizeof(char));
      
      memset(p_big_array,  0xA, SIZE_BYTES * sizeof(char));
      memset(p_dest_array, 0xF, SIZE_BYTES * sizeof(char));
        
      memcpy(p_dest_array, p_big_array, SIZE_BYTES * sizeof(char));
        
      free(p_dest_array);
      free(p_big_array);
      
      return 0;
    }

Assembly Output: This is the exact same on both the server and the laptop. I&#39;m saving space and not pasting both.

            .file   &quot;main_memcpy.cpp&quot;
            .section        .text.startup,&quot;ax&quot;,@progbits
            .p2align 4,,15
            .globl  main
            .type   main, @function
    main:
    .LFB25:
            .cfi_startproc
            pushq   %rbp
            .cfi_def_cfa_offset 16
            .cfi_offset 6, -16
            movl    $1073741824, %edi
            pushq   %rbx
            .cfi_def_cfa_offset 24
            .cfi_offset 3, -24
            subq    $8, %rsp
            .cfi_def_cfa_offset 32
            call    malloc
            movl    $1073741824, %edi
            movq    %rax, %rbx
            call    malloc
            movl    $1073741824, %edx
            movq    %rax, %rbp
            movl    $10, %esi
            movq    %rbx, %rdi
            call    memset
            movl    $1073741824, %edx
            movl    $15, %esi
            movq    %rbp, %rdi
            call    memset
            movl    $1073741824, %edx
            movq    %rbx, %rsi
            movq    %rbp, %rdi
            call    memcpy
            movq    %rbp, %rdi
            call    free
            movq    %rbx, %rdi
            call    free
            addq    $8, %rsp
            .cfi_def_cfa_offset 24
            xorl    %eax, %eax
            popq    %rbx
            .cfi_def_cfa_offset 16
            popq    %rbp
            .cfi_def_cfa_offset 8
            ret
            .cfi_endproc
    .LFE25:
            .size   main, .-main
            .ident  &quot;GCC: (GNU) 4.6.1&quot;
            .section        .note.GNU-stack,&quot;&quot;,@progbits


**PROGRESS!!!! asmlib**

Based on suggestion from @tbenson  i tried running with the [asmlib][2] version of memcpy. My results initially were poor but after changing SetMemcpyCacheLimit() to 1GB (size of my buffer) i was running at speed on par with my naive for loop!

Bad news is that the asmlib version of memmove is slower than the glibc version, it is now running at the 300ms mark (on par with the glibc version of memcpy). Weird thing is that on the laptop when i SetMemcpyCacheLimit() to a large number it hurts performance...

In the results below the lines marked with SetCache have SetMemcpyCacheLimit set to 1073741824. The results without SetCache do not call SetMemcpyCacheLimit()

Results using functions from asmlib:

    Buffer Size: 1GB  | memcpy (ms) | memmove(ms) | naiveMemcpy()
    ------------------------------------------------------------
    Laptop            | 136         | 132         | 161
    Laptop SetCache   | 182         | 137         | 161
    Server 1          | 305         | 302         | 164
    Server 1 SetCache | 162         | 303         | 164
    Server 2          | 300         | 299         | 166
    Server 2 SetCache | 166         | 301         | 166

Starting to lean towards cache issue, but what would cause this?

  [1]: http://i.stack.imgur.com/PTqZJ.png
  [2]: http://www.agner.org/optimize/asmlib.zip

Poor memcpy Performance on Linux

I&#39;m using an `SDL_Window` and `SDL_Renderer`.

Is it possible to use `SDL_TTF` with `SDL_Render/SDL_Window`?  If so, how?


How to render text in SDL2?

    #define DEFINE_STAT(Stat) \
	struct FThreadSafeStaticStat&lt;FStat_##Stat&gt; StatPtr_##Stat;

The above line is take from Unreal 4, and I know I could ask it over on the unreal forums, but I think this is a general C++ question that warrants being asked here.

I understand the first line defines a macro, however I am not well versed in preprocessor shenanigans in C++ and so I&#39;m lost over there. Logic tells me the backslash means the declaration continues onto the next line.

FThreadSafeStaticStat looks a bit like a template, but there&#39;s #&#39;s going on in there and a syntax I&#39;ve never seen before in C++

Could someone tell me what this means? I understand that you may not have access to Unreal 4, but it&#39;s just the syntax I don&#39;t understand.

What does ## (double hash) do in a preprocessor directive?

Just out of curiosity: why can I assign 0.0 to a variable that is of an enumeration type, but not 1.0? Have a look at the following code:

    public enum Foo
    {
        Bar,
        Baz
    }

    class Program
    {
        static void Main()
        {
            Foo value1 = 0.0;
            Foo value2 = 1.0;   // This line does not compile
            Foo value3 = 4.2;   // This line does not compile
        }
    }

I thought that conversions between numerical types and enumeration values are only allowed via casts? That is I could write Foo `value2 = (Foo) 1.0;` so that line 2 in `Main` can compile. Why is there an exception for the value `0.0` in C#? 

Why can I assign 0.0 to enumeration values, but not 1.0

I&#39;m trying to convert numbers taken from a UITextField, which I presume, are actually Strings, and convert them to Float, so I can multiply them.

I have two `UITextfield`s which are declared as follows:
    
    @IBOutlet var wage: UITextField
    @IBOutlet var hour: UITextField
   
When the user presses a UIButton I want to calculate the wages the user earns, but I can&#39;t, as I need to convert them to floats first, before I can use them.

I know how to convert them to an integer by doing this:
    
    var wageConversion:Int = 0
    wageConversion = wage.text.toInt()!
    

However, I have no idea how to convert them to floats.

Convert String to Float in Swift

If we execute the following C# code on a console application, we will get a message as `The sums are Not equal`.

If we execute it after uncommenting the line `System.Console.WriteLine()`, we will get a message as `The sums are equal`.

        static void Main(string[] args)
        {
            float f = Sum(0.1f, 0.2f);
            float g = Sum(0.1f, 0.2f);

            //System.Console.WriteLine(&quot;f = &quot; + f + &quot; and g = &quot; + g);

            if (f == g)
            {
                System.Console.WriteLine(&quot;The sums are equal&quot;);
            }
            else
            {
                System.Console.WriteLine(&quot;The sums are Not equal&quot;);
            }
        }

        static float Sum(float a, float b)
        {
            System.Console.WriteLine(a + b);
            return a + b;
        }

What is the actual reason for this behavior?


Will the scope of floating point variables affect their values?

When calling `Double.IsNaN()` with `Double.PositiveInfinity` as argument, the result is false. This is against my intuition since infinity is not a number. Apparently &quot;NaN&quot; only exists in terms of a constant in .NET, is this described by the IEEE standard or is it a custom implementation detail? Is there a shorter way to check if a `Double` is &quot;NaN&quot; than:

    (Double.IsNaN(d) || Double.IsPositiveInfinity(d) || Double.IsNegativeInfinity(d))

or

    (Double.IsNaN(d) || Double.IsInfinity(d))

Shortest way of checking if Double is &quot;NaN&quot;

When `x` is a `double`, is `(x - x)` guaranteed to be `+0.0`, or might it sometimes be `-0.0` (depending on the sign of `x`)?

Is (x - x) always positive zero for doubles, or sometimes negative zero?

I&#39;m trying to determine whether there is a naming convention for the names of `const` in Golang.

I personally would tend to follow the C style and write them in upper case, but I haven&#39;t found anything on this page http://golang.org/doc/effective_go.html which seems to list some naming conventions for the language.

Go naming conventions for const

I know that ES6 is not standardized yet, but a [lot of browsers currently support][1] `const` keyword in JS.

In spec, it is written that:

&gt; The value of a constant cannot change through re-assignment, and a
&gt; constant cannot be re-declared. Because of this, although it is
&gt; possible to declare a constant without initializing it, it would be
&gt; useless to do so.

and when I do something like this:

    const xxx = 6;
    xxx = 999;
    xxx++;
    const yyy = [];
    yyy = &#39;string&#39;;
    yyy = [15, &#39;a&#39;];
I see that everything is ok `xxx` is still `6` and `yyy` is `[]`.

But if I do `yyy.push(6); yyy.push(1); `, my constant array has been changed. Right now it is `[6, 1]` and by the way I still can not change it with `yyy = 1;`.

I this a bug, or am I missing something? I tried it in the latest chrome and FF29

  [1]: http://kangax.github.io/es5-compat-table/es6/

Why can I change a constant object in javascript

Is there any way to define static final variables (effectively constants) in a Java enum declaration?

What I want is to define in one place the string literal value for the BAR(1...n) values:
    
    @RequiredArgsConstructor
    public enum MyEnum {
        BAR1(BAR_VALUE),
        FOO(&quot;Foo&quot;),
        BAR2(BAR_VALUE),
        ...,
        BARn(BAR_VALUE);

        private static final String BAR_VALUE = &quot;Bar&quot;;

        @Getter
        private final String value;
    }

I got the following error message for the code above: **Cannot reference a field before it is defined**.

How to define static constants in a Java enum?

How can I check if a constant is defined in a PHP class?

    class Foo {
        const BAR = 1;
    }

Is there something like `property_exists()` or `method_exists()` for class constants? Or can I just use `defined(&quot;Foo::BAR&quot;)`?

Check if a class constant exists

In Swift, it seems that global constants should be camelCase.

For example:

    let maximumNumberOfLoginAttempts = 10

Is that correct?

I&#39;m used to all caps, e.g., `MAXIMUM_NUMBER_OF_LOGIN_ATTEMPTS`, from C, but I want to acquiesce to Swift conventions.

Content Type	Original Author	Original Content on Stackoverflow
Question	crush	View Question on Stackoverflow
Solution 1 - C	Mysticial	View Answer on Stackoverflow
Solution 2 - C	David Heffernan	View Answer on Stackoverflow

What does the constant 0.0039215689 represent?

C Problem Overview

C Solutions

Solution 1 - C

Solution 2 - C

Reading a resource file from within jar

Generate 'n' unique random numbers within a range

Attributions