Using the `free` command:

    % free
                 total       used       free     shared    buffers     cached
    Mem:       2061712     490924    1570788          0      60984     220236
    -/+ buffers/cache:     209704    1852008
    Swap:       587768          0     587768


Based on this output we grab the line with `Mem` and using awk pick specific fields for our computations.

This will report the percentage of memory in use

    % free | grep Mem | awk &#39;{print $3/$2 * 100.0}&#39;
    23.8171

This will report the percentage of memory that&#39;s free

    % free | grep Mem | awk &#39;{print $4/$2 * 100.0}&#39;
    76.5013

You could create an alias for this command or put this into a tiny shell script. The specific output could be tailored to your needs using formatting commands for the print statement along these lines:

    free | grep Mem | awk &#39;{ printf(&quot;free: %.4f %\n&quot;, $4/$2 * 100.0) }&#39;




I am using the Facebook like box code in my [side bar][1] by pasting the Facebook code into a text widget. My theme is responsive, and I&#39;d like to get the like box to resize correctly. I found this [tutorial][2] but he says the way he is doing it, isn&#39;t &quot;fully responsive&quot; so I didn&#39;t know if there was a better way to do it. 


  [1]: http://noahsdad.com/
  [2]: http://inspectelement.com/tutorials/how-to-make-the-facebook-like-box-responsive/

How to make the Facebook Like Box responsive?

A way to get `HTTP_REFERER` , We can use `document.referrer` in browser side javascript .
But how can we get it in NodeJS ?



How to get &quot;HTTP_REFERER&quot; with NodeJS?

I would like to get the available memory reported as a percentage using a Linux command line.

I used the `free` command, but that is only giving me numbers, and there is no option for percentage.

How to get the percentage of memory free with a Linux command?

<p>I would like to get the available memory reported as a percentage using a Linux command line.</p>
<p>I used the <code>free</code> command, but that is only giving me numbers, and there is no option for percentage.</p>


As far as I know, `initrd` acts as a block device, thus requiring a filesystem driver (such as `ext2`). The kernel must have at least one built-in module for detecting filesystem of `initrd`. In this article, [Introducing initramfs, a new model for initial RAM disks][1], it is written that:

&gt; But ramdisks actually waste even more memory due to caching. Linux is
&gt; designed to cache all files and directory entries read from or written
&gt; to block devices, so Linux copies data to and from the ramdisk into
&gt; the &quot;page cache&quot; (for file data), and the &quot;dentry cache&quot; (for
&gt; directory entries). The downside of the ramdisk pretending to be a
&gt; block device is it gets treated like a block device.

What&#39;s `page cache` and `dentry cache`? In the paragraph, does it mean the data got duplicated because `ramdisk` is treated as a block device, thus all the data is cached?

In constrast, `ramfs`:

&gt; A few years ago, Linus Torvalds had a neat idea: what if Linux&#39;s cache
&gt; could be mounted like a filesystem? Just keep the files in cache and
&gt; never get rid of them until they&#39;re deleted or the system reboots?
&gt; Linus wrote a tiny wrapper around the cache called &quot;ramfs&quot;, and other
&gt; kernel developers created an improved version called &quot;tmpfs&quot; (which
&gt; can write the data to swap space, and limit the size of a given mount
&gt; point so it fills up before consuming all available memory). Initramfs
&gt; is an instance of tmpfs.
&gt; 
&gt; These ram based filesystems automatically grow or shrink to fit the
&gt; size of the data they contain. Adding files to a ramfs (or extending
&gt; existing files) automatically allocates more memory, and deleting or
&gt; truncating files frees that memory. There&#39;s no duplication between
&gt; block device and cache, because there&#39;s no block device. The copy in
&gt; the cache is the only copy of the data. Best of all, this isn&#39;t new
&gt; code but a new application for the existing Linux caching code, which
&gt; means it adds almost no size, is very simple, and is based on
&gt; extremely well tested infrastructure.

In sum, `ramfs` is just file opened and loaded into memory, isn&#39;t it? 

Both `initrd` and `ramfs` are zipped at compile time, but the difference is, `initrd` is a block device unpacked to be mounted by the kernel at booting, while `ramfs` is unpacked via cpio into memory. Am I correct? Or is `ramfs` a very minimal file system?

Finally, up until this day, the `initrd` image is still presented in the latest kernel. However, is that `initrd` actually the `ramfs` used today and the name is just for historical purpose? 

  [1]: http://www.linuxfordevices.com/c/a/Linux-For-Devices-Articles/Introducing-initramfs-a-new-model-for-initial-RAM-disks/

The difference between initrd and initramfs?

I have a simple test program that when I run I get:

    ./hello: error while loading shared libraries: libaio.so.1: cannot open shared object file: No such file or directory

I link it like this:

    $(CC) $(CCFLAGS) -o hello hello.o -L../ocilib-3.9.3/src/.libs -L../instantclient_11_2 -locilib

My LD_LIBRARY_PATH contains this:

    LD_LIBRARY_PATH=../ocilib-3.9.3/src/.libs:../instantclient_11_2:/usr/lib

/usr/lib looks like this:

    Linux$ ls -l /usr/lib/libaio*
    lrwxrwxrwx  1 root root   15 Nov  5  2008 /usr/lib/libaio.so.1 -&gt; libaio.so.1.0.1
    -rwxr-xr-x  1 root root 2632 Sep 16  2005 /usr/lib/libaio.so.1.0.0
    -rwxr-xr-x  1 root root 2628 Sep 16  2005 /usr/lib/libaio.so.1.0.1

Output of ldd hello:

    libocilib.so.3 =&gt; ../ocilib-3.9.3/src/.libs/libocilib.so.3 (0x0000002a95558000)
    libc.so.6 =&gt; /lib64/tls/libc.so.6 (0x0000003811200000)
    libclntsh.so.11.1 =&gt; ../instantclient_11_2/libclntsh.so.11.1 (0x0000002a956c4000)
    /lib64/ld-linux-x86-64.so.2 (0x000000552aaaa000)
    libnnz11.so =&gt; ../instantclient_11_2/libnnz11.so (0x0000002a97f56000)
    libdl.so.2 =&gt; /lib64/libdl.so.2 (0x0000003811500000)
    libm.so.6 =&gt; /lib64/tls/libm.so.6 (0x0000003811700000)
    libpthread.so.0 =&gt; /lib64/tls/libpthread.so.0 (0x0000003811b00000)
    libnsl.so.1 =&gt; /lib64/libnsl.so.1 (0x0000003819000000)
    libaio.so.1 =&gt; not found

I&#39;m hoping that I&#39;m missing something simple here.  The oracle instantclient package appears to require libaio, but that seems to be installed already so what&#39;s the problem?


libaio.so.1: cannot open shared object file

How can you list all functions in a program with GDB?


Ask GDB to list all functions in a program

I am trying to work out how to make bash (force?) expand variables in a string (which was loaded from a file).

I have a file called &quot;something.txt&quot; with the contents: 

    hello $FOO world



I then run

    export FOO=42
    echo $(cat something.txt)

this returns: 

       hello $FOO world

It didn&#39;t expand $FOO even though the variable was set. I can&#39;t eval or source the file - as it will try and execute it (it isn&#39;t executable as it is - I just want the string with the variables interpolated). 

Any ideas? 



Forcing bash to expand variables in a string loaded from a file

Does the typical `malloc` (for x86-64 platform and Linux OS) naively lock a mutex at the beginning and release it when done, or does it lock a mutex in a more clever way at a finer level, so that lock contention is reduced? If it indeed does it the second way, how does it do it?

How does malloc work in a multithreaded environment?

How do I extract a zip to memory?

My attempt (returning `None` on `.getvalue()`):

    from zipfile import ZipFile
    from StringIO import StringIO

    def extract_zip(input_zip):
        return StringIO(ZipFile(input_zip).extractall())

Extracting a zipfile to memory?

What does the HotSpot JVM flag `-XX:+UseCompressedOops` do and when should I use it? What sort of performance and memory-usage differences will I see when using it on a 64-bit Java instance (vs. not using it)? 

What does the UseCompressedOops JVM flag do and when should I use it?

I have a routine that runs different queries against an SQLite database many times per second. After a while I would get the error 

`&quot;android.database.CursorWindowAllocationException: - Cursor window allocation of 2048 kb failed. # Open Cursors = &quot;` appear in LogCat.

 I had the app log memory usage, and indeed when usage reaches a certain limit the I get this error, implying it runs out. My intuition tells me that the database engine is creating a NEW buffer (CursorWindow) every time I run a query, and even though .close() the cursors, neither the garbage collector nor `SQLiteDatabase.releaseMemory()` are quick enough at freeing memory. I think the solution may lie in &quot;forcing&quot; the database to always write into the same buffer, and not create new ones, but I have been unable to find a way to do this. I have tried instantiating my own CursorWindow, and tried setting SQLiteCursor to it, but to no avail.

&#191;Any ideas?

EDIT: re example code request from @GrahamBorland:

    public static CursorWindow cursorWindow = new CursorWindow(&quot;cursorWindow&quot;); 
    public static SQLiteCursor sqlCursor;
    public static void getItemsVisibleArea(GeoPoint mapCenter, int latSpan, int lonSpan) {
    query = &quot;SELECT * FROM Items&quot;; //would be more complex in real code
    sqlCursor = (SQLiteCursor)db.rawQuery(query, null);
    sqlCursor.setWindow(cursorWindow);
    }

Ideally I would like to be able to `.setWindow()` before giving a new query, and have the data put into the same `CursorWindow` everytime I get new data. 

SQLite Android Database Cursor window allocation of 2048 kb failed

I don&#39;t understand the difference between assignment constructor and copy constructor in C++. It is like this:

&lt;!-- language: cpp --&gt;

    class A {
    public:
        A() {
            cout &lt;&lt; &quot;A::A()&quot; &lt;&lt; endl;
        }
    };

    // The copy constructor
    A a = b;

    // The assignment constructor
    A c;
    c = a;

    // Is it right?


I want to know how to allocate memory of the assignment constructor and copy constructor?


What&#39;s the difference between assignment operator and copy constructor?

I have a large .xlsx file (141 MB, containing 293413 lines with 62 columns each)  I need to perform some operations within.

I am having problems with loading this file (`OutOfMemoryError`), as POI has a large memory footprint on XSSF (xlsx) workbooks.

[This SO question][1] is similar, and the solution presented is to increase the VM&#39;s allocated/maximum memory.

It seems to work for that kind of file-size (9MB), but for me, it just simply doesn&#39;t work even if a allocate all available system memory. (Well, it&#39;s no surprise considering the file is over 15 times larger)

I&#39;d like to know if there is any way to load the workbook in a way it won&#39;t consume all the memory, and yet, without doing the processing based (going into) the XSSF&#39;s underlying XML. (In other words, maintaining a puritan POI solution)

If there isn&#39;t tough, you are welcome to say it (&quot;There isn&#39;t.&quot;) and point me the ways to a &quot;XML&quot; solution.

  [1]: https://stackoverflow.com/questions/6069847/java-lang-outofmemoryerror-java-heap-space-while-reading-excel-with-apache-poi

Content Type	Original Author	Original Content on Stackoverflow
Question	Timothy Clemans	View Question on Stackoverflow
Solution 1 - Linux	Levon	View Answer on Stackoverflow

How to get the percentage of memory free with a Linux command?

Linux Problem Overview

Linux Solutions

Solution 1 - Linux

How to get "HTTP_REFERER" with NodeJS?

How to make the Facebook Like Box responsive?

Attributions