No, at least not on Linux it&#39;s fine to close the file. 

[The manual page][1] clearly states:

&gt;  On the other hand, closing the file descriptor does not unmap the region.

For portability, I also checked the [POSIX manual](http://pubs.opengroup.org/onlinepubs/7908799/xsh/mmap.html), it says the same thing (although even more clearly):

&gt; The *mmap()* function adds an extra reference to the file associated with the file descriptor *fildes* which is not removed by a subsequent *close()* on that file descriptor. This reference is removed when there are no more mappings to the file. 

  [1]: http://linux.die.net/man/2/mmap

I&#39;ve got a question of some strange String pool behavior.
I&#39;m using `==` to compare equal Strings to find out whether they&#39;re in the pool or not.

    public class StringPoolTest {
      public static void main(String[] args) {
        new StringPoolTest().run();
      }
    
      String giveLiteralString() {
        return &quot;555&quot;;
      }
    
      void run() {
        String s1 = giveLiteralString() + &quot;&quot;;
        System.out.println(&quot;555&quot; == &quot;555&quot; + &quot;&quot;);
        System.out.println(giveLiteralString() == giveLiteralString() + &quot;&quot;);
      }
    }

The output is:

    true
    false

which is a big surprise for me. Could anyone explain this please?
I think something about this is taking place at the compilation time. But why does adding `&quot;&quot;` to a String makes any difference at all?



Strange String pool behavior

What is the way to list all global variables that have been used by the site? Can any browser javascript debugger do that? By used I mean READ, not changed/added. Detect iframe ones, would be nice too.

PLEASE NOTE:
I need to get a list of global variables &quot;touched&quot; by site. Not all of them or added ones or edited ones, the ones that were used anywhere in the site scripts.

List all js global variables used by site (not all defined!)

I have a program that maps quite a few (100&#39;s) of sizable files 10-100MB each. I need them all mapped at the same time.

At the moment I am calling `open` followed by `mmap` at the beginning of the program, followed by `munmap` and `close` at the end.

Often I have to adjust the open files limit running `ulimit -n` before running the program.

Question is do I actually need to keep the files open, or can I `open` `mmap` `close` do some large data processing then `munmap` when I&#39;m finished.

The man pages of `mmap` do not seem terribly clear to me on this one.

Do I need to keep a file open after calling mmap on it?

I have a program that maps quite a few (100's) of sizable files 10-100MB each. I need them all mapped at the same time.
At the moment I am calling <code>open</code> followed by <code>mmap</code> at the beginning of the program, followed by <code>munmap</code> and <code>close</code> at the end.
Often I have to adjust the open files limit running <code>ulimit -n</code> before running the program.
Question is do I actually need to keep the files open, or can I <code>open</code> <code>mmap</code> <code>close</code> do some large data processing then <code>munmap</code> when I'm finished.
The man pages of <code>mmap</code> do not seem terribly clear to me on this one.

Question
========

I&#39;m porting a C application into C#. The C app calls lots of functions from a 3rd-party DLL, so I wrote P/Invoke wrappers for these functions in C#. Some of these C functions allocate data which I have to use in the C# app, so I used `IntPtr`&#39;s, [`Marshal.PtrToStructure`][1] and [`Marshal.Copy`][2] to copy the native data (arrays and structures) into managed variables. 

Unfortunately, the C# app proved to be much slower than the C version. A quick performance analysis showed that the above mentioned marshaling-based data copying is the bottleneck. **I&#39;m considering to speed up the C# code by rewriting it to use pointers instead.** Since I don&#39;t have experience with unsafe code and pointers in C#, I need expert opinion regarding the following **questions**:

1. What are the drawbacks of using `unsafe` code and pointers instead of `IntPtr` and `Marshal`ing? For example, is it more unsafe (pun intended) in any way? People seem to prefer marshaling, but I don&#39;t know why.
2. Is using pointers for P/Invoking really faster than using marshaling? How much speedup can be expected approximately? I couldn&#39;t find any benchmark tests for this.

Example code
============

To make the situation more clear, I hacked together a small example code (the real code is much more complex). I hope this example shows what I mean when I&#39;m talking about &quot;unsafe code and pointers&quot; vs. &quot;IntPtr and Marshal&quot;.

C library (DLL)
---------------

MyLib.h

    #ifndef _MY_LIB_H_
    #define _MY_LIB_H_
    
    struct MyData 
    {
      int length;
      unsigned char* bytes;
    };
    
    __declspec(dllexport) void CreateMyData(struct MyData** myData, int length);
    __declspec(dllexport) void DestroyMyData(struct MyData* myData);
    
    #endif // _MY_LIB_H_

MyLib.c

    #include &lt;stdlib.h&gt;
    #include &quot;MyLib.h&quot;
    
    void CreateMyData(struct MyData** myData, int length)
    {
      int i;
    
      *myData = (struct MyData*)malloc(sizeof(struct MyData));
      if (*myData != NULL)
      {
        (*myData)-&gt;length = length;
        (*myData)-&gt;bytes = (unsigned char*)malloc(length * sizeof(char));
        if ((*myData)-&gt;bytes != NULL)
          for (i = 0; i &lt; length; ++i)
            (*myData)-&gt;bytes[i] = (unsigned char)(i % 256);
      }
    }
    
    void DestroyMyData(struct MyData* myData)
    {
      if (myData != NULL)
      {
        if (myData-&gt;bytes != NULL)
          free(myData-&gt;bytes);
        free(myData);
      }
    }

C application
-------------

Main.c

    #include &lt;stdio.h&gt;
    #include &quot;MyLib.h&quot;
    
    void main()
    {
      struct MyData* myData = NULL;
      int length = 100 * 1024 * 1024;
    
      printf(&quot;=== C++ test ===\n&quot;);
      CreateMyData(&amp;myData, length);
      if (myData != NULL)
      {
        printf(&quot;Length: %d\n&quot;, myData-&gt;length);
        if (myData-&gt;bytes != NULL)
          printf(&quot;First: %d, last: %d\n&quot;, myData-&gt;bytes[0], myData-&gt;bytes[myData-&gt;length - 1]);
        else
          printf(&quot;myData-&gt;bytes is NULL&quot;);
      }
      else
        printf(&quot;myData is NULL\n&quot;);
      DestroyMyData(myData);
      getchar();
    }

C# application, which uses `IntPtr` and `Marshal`
-------------------------------------------------

Program.cs

    using System;
    using System.Runtime.InteropServices;
    
    public static class Program
    {
      [StructLayout(LayoutKind.Sequential)]
      private struct MyData
      {
        public int Length;
        public IntPtr Bytes;
      }
    
      [DllImport(&quot;MyLib.dll&quot;)]
      private static extern void CreateMyData(out IntPtr myData, int length);
    
      [DllImport(&quot;MyLib.dll&quot;)]
      private static extern void DestroyMyData(IntPtr myData);
    
      public static void Main()
      {
        Console.WriteLine(&quot;=== C# test, using IntPtr and Marshal ===&quot;);
        int length = 100 * 1024 * 1024;
        IntPtr myData1;
        CreateMyData(out myData1, length);
        if (myData1 != IntPtr.Zero)
        {
          MyData myData2 = (MyData)Marshal.PtrToStructure(myData1, typeof(MyData));
          Console.WriteLine(&quot;Length: {0}&quot;, myData2.Length);
          if (myData2.Bytes != IntPtr.Zero)
          {
            byte[] bytes = new byte[myData2.Length];
            Marshal.Copy(myData2.Bytes, bytes, 0, myData2.Length);
            Console.WriteLine(&quot;First: {0}, last: {1}&quot;, bytes[0], bytes[myData2.Length - 1]);
          }
          else
            Console.WriteLine(&quot;myData.Bytes is IntPtr.Zero&quot;);
        }
        else
          Console.WriteLine(&quot;myData is IntPtr.Zero&quot;);
        DestroyMyData(myData1);
        Console.ReadKey(true);
      }
    }

C# application, which uses `unsafe` code and pointers
-----------------------------------------------------

Program.cs

    using System;
    using System.Runtime.InteropServices;
    
    public static class Program
    {
      [StructLayout(LayoutKind.Sequential)]
      private unsafe struct MyData
      {
        public int Length;
        public byte* Bytes;
      }
    
      [DllImport(&quot;MyLib.dll&quot;)]
      private unsafe static extern void CreateMyData(out MyData* myData, int length);
    
      [DllImport(&quot;MyLib.dll&quot;)]
      private unsafe static extern void DestroyMyData(MyData* myData);
    
      public unsafe static void Main()
      {
        Console.WriteLine(&quot;=== C# test, using unsafe code ===&quot;);
        int length = 100 * 1024 * 1024;
        MyData* myData;
        CreateMyData(out myData, length);
        if (myData != null)
        {
          Console.WriteLine(&quot;Length: {0}&quot;, myData-&gt;Length);
          if (myData-&gt;Bytes != null)
            Console.WriteLine(&quot;First: {0}, last: {1}&quot;, myData-&gt;Bytes[0], myData-&gt;Bytes[myData-&gt;Length - 1]);
          else
            Console.WriteLine(&quot;myData.Bytes is null&quot;);
        }
        else
          Console.WriteLine(&quot;myData is null&quot;);
        DestroyMyData(myData);
        Console.ReadKey(true);
      }
    }


  [1]: http://msdn.microsoft.com/en-us/library/system.runtime.interopservices.marshal.ptrtostructure.aspx
  [2]: http://msdn.microsoft.com/en-us/library/system.runtime.interopservices.marshal.copy.aspx







C# performance - Using unsafe pointers instead of IntPtr and Marshal

Does anyone have an example of code that can write to a binary file. And also code that can read a binary file and output to screen.  Looking at examples I can write to a file ok But when I try to read from a file it is not outputting correctly.

Read and write to binary files in C?

It is nearly impossible(*) to provide strict IEEE 754 semantics at reasonable cost when the only floating-point instructions one is allowed to used are the 387 ones. It is particularly hard when one wishes to keep the FPU working on the full 64-bit significand so that the `long double` type is available for extended precision. The usual “solution” is to do intermediate computations at the only available precision, and to convert to the lower precision at more or less well-defined occasions.

Recent versions of GCC handle excess precision in intermediate computations according to the interpretation laid out by Joseph S. Myers in a [2008 post to the GCC mailing list][2]. This description makes a program compiled with `gcc -std=c99 -mno-sse2 -mfpmath=387` completely predictable, to the last bit, as far as I understand. And if by chance it doesn&#39;t, it is a bug and it will be fixed: Joseph S. Myers&#39; stated intention in his post is to make it predictable.

Is it documented how Clang handles excess precision (say when the option `-mno-sse2` is used), and where?

(*) EDIT: this is an exaggeration. It is [slightly annoying but not that difficult][1] to emulate binary64 when one is allowed to configure the x87 FPU to use a 53-bit significand.

----------

Following a comment by R.. below, here is the log of a short interaction of mine with the most recent version of Clang I have :

    Hexa:~ $ clang -v
    Apple clang version 4.1 (tags/Apple/clang-421.11.66) (based on LLVM 3.1svn)
    Target: x86_64-apple-darwin12.4.0
    Thread model: posix
    Hexa:~ $ cat fem.c
    #include &lt;stdio.h&gt;
    #include &lt;math.h&gt;
    #include &lt;float.h&gt;
    #include &lt;fenv.h&gt;
    
    double x;
    double y = 2.0;
    double z = 1.0;
    
    int main(){
      x = y + z;
      printf(&quot;%d\n&quot;, (int) FLT_EVAL_METHOD);
    }
    Hexa:~ $ clang -std=c99 -mno-sse2 fem.c
    Hexa:~ $ ./a.out 
    0
    Hexa:~ $ clang -std=c99 -mno-sse2 -S fem.c
    Hexa:~ $ cat fem.s 
    …
    	movl	$0, %esi
    	fldl	_y(%rip)
    	fldl	_z(%rip)
    	faddp	%st(1)
    	movq	_x@GOTPCREL(%rip), %rax
    	fstpl	(%rax)
    …


  [1]: https://stackoverflow.com/questions/18496560/how-do-java-runtimes-targeting-pre-sse2-processors-implement-floating-point-basi
  [2]: http://gcc.gnu.org/ml/gcc-patches/2008-11/msg00105.html

Is there a document describing how Clang handles excess floating-point precision?

What is `ffreestanding` in gcc ? What is it used for ? I came across the following :

    gcc -ffreestanding -m32 -c kernel.c -o kernel.o

and do not understand, what does it mean exactly.


What is -ffreestanding option in gcc?

As the title says, I have this code:
```c
    typedef struct Book{
        int id;
        char title[256];
        char summary[2048];
        int numberOfAuthors;
        struct Author *authors;
    };


    typedef struct Author{
        char firstName[56];
        char lastName[56];
    };


    typedef struct Books{
        struct Book *arr;
        int numberOfBooks;
    };
```


I get these errors from gcc :

    bookstore.c:8:2: error: unknown type name ‘Author’
    bookstore.c:9:1: warning: useless storage class specifier in empty declaration [enabled by default]
    bookstore.c:15:1: warning: useless storage class specifier in empty declaration [enabled by default]
    bookstore.c:21:2: error: unknown type name ‘Book’
    bookstore.c:23:1: warning: useless storage class specifier in empty declaration [enabled by default]



No warnings and no errors occur if I change the typedefs like this:

```c
    typedef struct{
        char firstName[56];
        char lastName[56];
    } Author;
```

Having searched through _[C Programming Language, 2nd Edition][1]_ and googled for a couple of hours, I can&#39;t figure out why the first implementation won&#39;t work.
    
[1]:http://www.amazon.com/C-Programming-Language-2nd-Edition/dp/0131103628

C : typedef struct name {...}; VS typedef struct{...} name;

In [this](https://stackoverflow.com/questions/5656530/how-to-use-shared-memory-with-linux-in-c) thread the OP is suggested to use `mmap()` instead of `shmget()` to get shared memory in Linux.
I visited [this](http://www.cs.cf.ac.uk/Dave/C/node27.html) page and [this](http://www.jimscode.ca/index.php/component/content/article/13-c/45-c-simple-mmap-example) page to get some documentation, but the second one gives an obscure example regarding `mmap()`.

Being almost a newbie, and needing to share some information (in text form) between two processes, should I use the `shmget()` method or `mmap()`? And why?

Linux shared memory: shmget() vs mmap()?

I am banging my head into the wall with this.

In my project, when I&#39;m allocating memory with ```mmap``` the mapping (```/proc/self/maps```) shows that it is an readable and executable region **despite** I requested only readable memory.

After looking into strace (which was looking good) and other debugging, I was able to identify the only thing that seems to avoid this strange problem: removing assembly files from the project and leaving only pure C. (what?!)

So here is my strange example, I am working on Ubunbtu 19.04 and default gcc.

If you compile the target executable with the ASM file (which is empty) then ```mmap``` returns a readable and executable region, if you build without then it behave correctly. See the output of ```/proc/self/maps``` which I have embedded in my example.

**example.c**
```
#include &lt;stdio.h&gt;
#include &lt;string.h&gt;
#include &lt;sys/mman.h&gt;

int main()
{
    void* p;
    p = mmap(NULL, 8192,PROT_READ,MAP_ANONYMOUS|MAP_PRIVATE,-1,0);
    
    {
        FILE *f;
        char line[512], s_search[17];
        snprintf(s_search,16,&quot;%lx&quot;,(long)p);
        f = fopen(&quot;/proc/self/maps&quot;,&quot;r&quot;);
        while (fgets(line,512,f))
        {
            if (strstr(line,s_search)) fputs(line,stderr);
        }
        
        fclose(f);
    }

    return 0;
}
```
**example.s**: Is an empty file!

**Outputs**

With the ASM included version
```
VirtualBox:~/mechanics/build$ gcc example.c example.s -o example &amp;&amp; ./example
7f78d6e08000-7f78d6e0a000 r-xp 00000000 00:00 0 
```
Without the ASM included version
```
VirtualBox:~/mechanics/build$ gcc example.c -o example &amp;&amp; ./example
7f1569296000-7f1569298000 r--p 00000000 00:00 0 
```




Content Type	Original Author	Original Content on Stackoverflow
Question	camelccc	View Question on Stackoverflow
Solution 1 - C	unwind	View Answer on Stackoverflow

Do I need to keep a file open after calling mmap on it?

C Problem Overview

C Solutions

Solution 1 - C

List all js global variables used by site (not all defined!)

Strange String pool behavior

Attributions