mem_cgroup_uncharge()
  Called when a page's refcount goes down to 0.

mem_cgroup_uncharge_swap()
  Called when swp_entry's refcnt goes down to 0. A charge against swap
  disappears.

Memcg pages are charged in two steps:

	- mem_cgroup_try_charge()
	- mem_cgroup_commit_charge() or mem_cgroup_cancel_charge()

At try_charge(), there are no flags to say "this page is charged".
at this point, usage += PAGE_SIZE.

At commit(), the page is associated with the memcg.

At cancel(), simply usage -= PAGE_SIZE.

When you do test to do racy case, it's good test to set memcg's limit
to be very small rather than GB. Many races found in the test under
xKB or xxMB limits.

(Memory behavior under GB and Memory behavior under MB shows very
different situation.)

Historically, memcg's shmem handling was poor and we saw some amount
of troubles here. This is because shmem is page-cache but can be
SwapCache. Test with shmem/tmpfs is always good test.

For NUMA, migration is an another special case. To do easy test, cpuset
is useful. Following is a sample script to do migration::

	mount -t cgroup -o cpuset none /opt/cpuset

	mkdir /opt/cpuset/01
	echo 1 > /opt/cpuset/01/cpuset.cpus
	echo 0 > /opt/cpuset/01/cpuset.mems
	echo 1 > /opt/cpuset/01/cpuset.memory_migrate
	mkdir /opt/cpuset/02
	echo 1 > /opt/cpuset/02/cpuset.cpus
	echo 1 > /opt/cpuset/02/cpuset.mems
	echo 1 > /opt/cpuset/02/cpuset.memory_migrate

In above set, when you moves a task from 01 to 02, page migration to
node 0 to node 1 will occur. Following is a script to migrate all
under cpuset.::

	--
	move_task()
	{
	for pid in $1
	do
		/bin/echo $pid >$2/tasks 2>/dev/null
		echo -n $pid
		echo -n " "
	done
	echo END
	}

	G1_TASK=`cat ${G1}/tasks`
	G2_TASK=`cat ${G2}/tasks`
	move_task "${G1_TASK}" ${G2} &
	--

memory hotplug test is one of good test.

to offline memory, do following::

	# echo offline > /sys/devices/system/memory/memoryXXX/state

(XXX is the place of memory)

This is an easy way to test page migration, too.

Use tests like the following for testing nested cgroups::

	mkdir /opt/cgroup/01/child_a
	mkdir /opt/cgroup/01/child_b

	set limit to 01.
	add limit to 01/child_b
	run jobs under child_a and child_b

create/delete following groups at random while jobs are running::

	/opt/cgroup/01/child_a/child_aa
	/opt/cgroup/01/child_b/child_bb
	/opt/cgroup/01/child_c

running new jobs in new group is also good.

Mounting with other subsystems is a good test because there is a
race and lock dependency with other cgroup subsystems.

example::

	# mount -t cgroup none /cgroup -o cpuset,memory,cpu,devices

and do task move, mkdir, rmdir etc...under this.

Besides management of swap is one of complicated parts of memcg,
call path of swap-in at swapoff is not same as usual swap-in path..
It's worth to be tested explicitly.

For example, test like following is good:

(Shell-A)::

	# mount -t cgroup none /cgroup -o memory
	# mkdir /cgroup/test
	# echo 40M > /cgroup/test/memory.limit_in_bytes
	# echo 0 > /cgroup/test/tasks

Run malloc(100M) program under this. You'll see 60M of swaps.

(Shell-B)::

	# move all tasks in /cgroup/test to /cgroup
	# /sbin/swapoff -a
	# rmdir /cgroup/test
	# kill malloc task.

Of course, tmpfs v.s. swapoff test should be tested, too.

Out-of-memory caused by memcg's limit will kill tasks under
the memcg. When hierarchy is used, a task under hierarchy
will be killed by the kernel.

In this case, panic_on_oom shouldn't be invoked and tasks
in other groups shouldn't be killed.

It's not difficult to cause OOM under memcg as following.

Case A) when you can swapoff::

	#swapoff -a
	#echo 50M > /memory.limit_in_bytes

run 51M of malloc

Case B) when you use mem+swap limitation::

	#echo 50M > memory.limit_in_bytes
	#echo 50M > memory.memsw.limit_in_bytes

run 51M of malloc

Charges associated with a task can be moved along with task migration.

(Shell-A)::

	#mkdir /cgroup/A
	#echo $$ >/cgroup/A/tasks

run some programs which uses some amount of memory in /cgroup/A.

(Shell-B)::

	#mkdir /cgroup/B
	#echo 1 >/cgroup/B/memory.move_charge_at_immigrate
	#echo "pid of the program running in group A" >/cgroup/B/tasks

You can see charges have been moved by reading ``*.usage_in_bytes`` or
memory.stat of both A and B.

See 8.2 of Documentation/admin-guide/cgroup-v1/memory.rst to see what value should
be written to move_charge_at_immigrate.

Memory controller implements memory thresholds using cgroups notification
API. You can use tools/cgroup/cgroup_event_listener.c to test it.

(Shell-A) Create cgroup and run event listener::

	# mkdir /cgroup/A
	# ./cgroup_event_listener /cgroup/A/memory.usage_in_bytes 5M

(Shell-B) Add task to cgroup and try to allocate and free memory::

	# echo $$ >/cgroup/A/tasks
	# a="$(dd if=/dev/zero bs=1M count=10)"
	# a=

You will see message from cgroup_event_listener every time you cross
the thresholds.

Use /cgroup/A/memory.memsw.usage_in_bytes to test memsw thresholds.

It's good idea to test root cgroup as well.