Monthly Archives: November 2013

define _WIN32_WINNT

1. #define _WIN32_WINNT = 0x0501
2. -D _WIN32_WINNT=0x0501
3. Properties>C/C++>Proporcessor heading, _WIN32_WINNT = 0x0501.

it is needed to call winuser API defined for XP above

Windows Open Source Environment

MinGW, a contraction of “Minimalist GNU for Windows”, is a minimalist development environment for native Microsoft Windows applications.

What’s Difference between Cygwin and MinGW?

MinGW,== Native windows apps

Cygwin == Unix on windows


MinGW provides a complete Open Source programming tool set which is suitable for the development of native MS-Windows applications, and which do not depend on any 3rd-party C-Runtime DLLs. (It does depend on a number of DLLs provided by Microsoft themselves, as components of the operating system; most notable among these is MSVCRT.DLL, the Microsoft C runtime library. Additionally, threaded applications must ship with a freely distributable thread support DLL, provided as part of MinGW itself).

MinGW compilers provide access to the functionality of the Microsoft C runtime and some language-specific runtimes. MinGW, being Minimalist, does not, and never will, attempt to provide a POSIX runtime environment for POSIX application deployment on MS-Windows. If you want POSIX application deployment on this platform, please consider Cygwin instead.


Primarily intended for use by developers working on the native MS-Windows platform, but also available for cross-hosted use, (see note below — you may need to follow the “read more” link to see it), MinGW includes:

o    A port of the GNU Compiler Collection (GCC), including C, C++, ADA and Fortran compilers;

o    GNU Binutils for Windows (assembler, linker, archive manager)

o    A command-line installer (mingw-get) for MinGW and MSYS deployment on MS-Windows

o    A GUI wrapper (mingw-get-inst) for the command line installer

MSYS, a contraction of “Minimal SYStem”, is a Bourne Shell command line interpreter system. Offered as an alternative to Microsoft’s cmd.exe, this provides a general purpose command line environment, which is particularly suited to use with MinGW, for porting of many Open Source applications to the MS-Windows platform; a light-weight fork of Cygwin-1.3, it includes a small selection of Unix tools, chosen to facilitate that objective.






user mode OOM for LAMP


use strict;
use warnings;
use Proc::ProcessTable;

my $table = Proc::ProcessTable->new;
my $doeskill=0;
for my $process (@{$table->table}) {
# skip root processes
#next if $process->uid == 0 or $process->gid == 0;

# skip anything other than Passenger application processes
next unless $process->fname =~/apache2|php|mysql/;

# skip any using less than 0.5 GiB
next if $process->rss < 1024*1024*512; # document the slaughter (my $cmd = $process->cmndline) =~ s/\s+\z//;
print “Killing process: pid=”, $process->pid, ” uid=”, $process->uid, ” rss=”, $process->rss, ” fname=”, $process->fname, ” cmndline=”, $cmd, “\n”;

# try first to terminate process politely
kill 15, $process->pid;

# wait a little, then kill ruthlessly if it’s still around
sleep 5;
kill 9, $process->pid;

print “restarting apache and mysql\n”;
`/usr/sbin/service apache2 restart`;
`/usr/sbin/service mysql restart`;
print “clean, no need restart web\n”;

overcommit_memory and overcommit_ratio

This is system level setting that control how process can allocate memory from system. In C++, it directly working under malloc

  • 0: not allow over commit — Default
    1: allow any malloc
    2: ALlow malloc tile % physical memory + swap
  • echo 2 > /proc/sys/vm/overcommit_memory
    echo 50 > /proc/sys/vm/overcommit_ratio

    grep Committed_AS /proc/meminfo


    Since 2.5.30 the values are:
    0 (default): as before: guess about how much overcommitment is reasonable,
    1: never refuse any malloc(),
    2: be precise about the overcommit – never commit a virtual address space larger than swap space plus a fraction overcommit_ratio of the physical memory.

    Here /proc/sys/vm/overcommit_ratio (by default 50) is another user-settable parameter. It is possible to set overcommit_ratio to values larger than 100.

    # echo 2 > /proc/sys/vm/overcommit_memory

    # echo 80 > /proc/sys/vm/overcommit_ratio

    We set the system overcommit to be “allow malloc, but refust when 80% of Physical mem+SWAP been used.

    One can view the currently committed amount of memory in /proc/meminfo, in the field Committed_AS.

    OK, what about process level?

    ulimit this control at per shell basis.
    run ulimit directly will show it’s current setting.

    ulimit [-HSTabcdefilmnpqrstuvx [limit]]
    Provides control over the resources available to the shell and to processes started by it, on systems that allow such control. The -H and -S options specify that the hard or soft limit
    is set for the given resource. A hard limit cannot be increased by a non-root user once it is set; a soft limit may be increased up to the value of the hard limit. If neither -H nor -S
    is specified, both the soft and hard limits are set. The value of limit can be a number in the unit specified for the resource or one of the special values hard, soft, or unlimited,

    which stand for the current hard limit, the current soft limit, and no limit, respectively. If limit is omitted, the current value of the soft limit of the resource is printed, unless
    the -H option is given. When more than one resource is specified, the limit name and unit are printed before the value. Other options are interpreted as follows:
    -a All current limits are reported
    -b The maximum socket buffer size
    -c The maximum size of core files created
    -d The maximum size of a process’s data segment
    -e The maximum scheduling priority (“nice”)
    -f The maximum size of files written by the shell and its children
    -i The maximum number of pending signals
    -l The maximum size that may be locked into memory
    -m The maximum resident set size (many systems do not honor this limit)
    -n The maximum number of open file descriptors (most systems do not allow this value to be set)
    -p The pipe size in 512-byte blocks (this may not be set)
    -q The maximum number of bytes in POSIX message queues
    -r The maximum real-time scheduling priority
    -s The maximum stack size
    -t The maximum amount of cpu time in seconds
    -u The maximum number of processes available to a single user
    -v The maximum amount of virtual memory available to the shell and, on some systems, to its children
    -x The maximum number of file locks
    -T The maximum number of threads

    If limit is given, and the -a option is not used, limit is the new value of the specified resource. If no option is given, then -f is assumed. Values are in 1024-byte increments, except
    for -t, which is in seconds; -p, which is in units of 512-byte blocks; and -T, -b, -n, and -u, which are unscaled values. The return status is 0 unless an invalid option or argument is
    supplied, or an error occurs while setting a new limit.

    ulimit -v 1024 this limit the Virtual memory max usage for this current shell process.

    To know how much Virtual memory used by one process, run ps -aux look for it’s VSZ value.

    RSS is the Resident Set Size and is used to show how much memory is allocated to that process and is in RAM. It does not include memory that is swapped out. It does include memory from shared libraries as long as the pages from those libraries are actually in memory. It does include all stack and heap memory.

    VSZ is the Virtual Memory Size. It includes all memory that the process can access, including memory that is swapped out and memory that is from shared libraries.

    Mysql: max_allowed_packet

    Replication and max_allowed_packet
    max_allowed_packet sets an upper limit on the size of any single message between the MySQL server and clients, including replication slaves. If you are replicating large column values (such as might be found in TEXT or BLOB columns) and max_allowed_packet is too small on the master, the master fails with an error, and the slave shuts down the I/O thread. If max_allowed_packet is too small on the slave, this also causes the slave to stop the I/O thread.

    Row-based replication currently sends all columns and column values for updated rows from the master to the slave, including values of columns that were not actually changed by the update. This means that, when you are replicating large column values using row-based replication, you must take care to set max_allowed_packet large enough to accommodate the largest row in any table to be replicated, even if you are replicating updates only, or you are inserting only relatively small values.

    Linux Iptables apache 1

    #  Allow all loopback (lo0) traffic and drop all traffic to 127/8 that doesn't use lo0
    -A INPUT -i lo -j ACCEPT
    -A INPUT -d -j REJECT
    #  Accept all established inbound connections
    #  Allow all outbound traffic - you can modify this to only allow certain traffic
    #  Allow HTTP and HTTPS connections from anywhere (the normal ports for websites and SSL).
    -A INPUT -p tcp --dport 80 -j ACCEPT
    -A INPUT -p tcp --dport 443 -j ACCEPT
    #  Allow SSH connections
    #  The -dport number should be the same port number you set in sshd_config
    -A INPUT -p tcp -m state --state NEW --dport 22 -j ACCEPT
    #  Allow ping
    -A INPUT -p icmp -j ACCEPT
    #  Log iptables denied calls
    -A INPUT -m limit --limit 5/min -j LOG --log-prefix "iptables denied: " --log-level 7
    #  Drop all other inbound - default deny unless explicitly allowed policy
    -A INPUT -j DROP