Command to release the best amount of Kernel Task and Memory Ram

kernelmemoryperformance

I have an old MacBook Pro 2012/2013 and it has the El Capitan

Through the Utilities -> Activity Monitor tool I can get the following stats according the following behavior:

For example if the Mac is just started the Kernel Task has 500MB and Memory Ram has 2.0 GB, if I just open Firefox the two components increase (how is expected) lets say to 750MB and 2.5GB respectively. If I close Firefox (Cmd + Q), I would expect that the values return to 500MB and 2.0GB respectively. Well it does not happen how is expected, for example: the Kernel Task returns to 650MB (and not to 500MB) and the Memory Ram returns to 2.2GB (and not 2.0GB).

I have this behavior with other programs apart of Firefox.

Is there a command where I can free in general all the kernel task and memory ram? At least to the best acceptable minimum values according to the OS itself after to execute the command.

The goal is after to execute some "heavy" software development tools and servers (therefore when they have just been closed), release the best amount of resources of these two components.

Best Answer

There's no ordinary system command for that purpose - simply because it is not what you would normally want.

The memory used here will help the performance of your system by caching data that might be needed later. If it is not needed later, because you need to load something different in RAM, the caches will be released automatically.

However, you can simulate such a command by simply making a small program that allocates progressively larger amounts of memory until you have cleared up all caches. There's no real point in doing so however as it won't help your system run faster, or be able to run more programs or anything like that.

Related Solutions

MacOS – How to diagnose really poor performance of the 13″ MBP 2011 on 10.6

When the wired and active RAM pass 50% - most tasks are measurably slower. You will see increased paging activity (vm_stat 15 in the terminal - watch for page outs - they indicate some memory had to be written to slow hard drive and constant page out and page in above 10-20 per minute indicates you have a RAM starved system.)

When starved for RAM, you can buy more or do less. You might want to get a monitoring software like Activity Monitor and keep the memory indicator in your dock. The system is likely thrashing based on the time delays you report. Each of the active programs needs some memory that just got paged to disk to free up extra space for memory needed by another program. It is a bad cycle and the computer just spends time running circles rather than getting done the work you wanted.

Here is a mac with every indication of RAM pressure:

time for more RAM

But, quitting a large app like Aperture and starting it again still has no paging and the system is very responsive. Ignore the first line after the headings in vm_stat as it's the total since boot, but do watch for pageout as you have apps that are not responsive:

mac:~ me$ vm_stat 15
Mach Virtual Memory Statistics: (page size of 4096 bytes, cache hits 0%)
  free active   spec inactive   wire   faults     copy    0fill reactive  pageins  pageout
260482  1186K  74303   275275 234520  323478K  2276158  188709K   120292   640158      482 
260689  1187K  74303   275275 234038     4117        0     3256        0        0        0 
261310  1185K  74001   275250 235835    10668       77     7115        0        4        0 
292087  1153K  74711   274313 236770    32927      972    21684        0       18        0 
521469 928347  75754   269861 235897    77208      130    63300        8       41        0 
517897 936518  75766   269215 231981    27678     2504    13059        0       22        0 
463894 987202  72076   274852 233371   126855     2712    89422        2       50        0 
223701  1180K  77834   283568 265396   589512      255   562957        1     7278        0 
205013  1186K  82765   291561 265293   389442      255   369664        0     7334        0 
201401  1173K  89671   301672 265595   495426       82   472316        1     9286        0

However, starting about 4 of the Adobe CS4 apps can push this machine into thrashing and the slowness you describe with the apps taking 30 seconds to launch and lots of bouncing of square icons in the dock.

dock bounce

Here is the associated vm_stat 15 showing the problem. Look specifically at the free memory plummeting to the minimum and pagein / pageout climbing.

mac:~ me$ vm_stat 15
Mach Virtual Memory Statistics: (page size of 4096 bytes, cache hits 0%)
  free active   spec inactive   wire   faults     copy    0fill reactive  pageins  pageout
 21822  1190K   4746   585056 228411  332621K  2315577  196418K   121439   781551     1806 
 86862  1152K   5123   570803 215710   124555      932   102117        0     2086       15 
 73080  1161K   8631   571301 216607    24404      337    14931        0     1994        0 
 29655  1196K  13500   572024 219284   188966      535   112913        0     3606        0 
  1668  1208K   9616   594723 216954   174145      215   144996       16    15268      121 
  4142  1206K   5795   595393 219564   322750        0   320426        0        1        0 
  3043  1204K   3485   596990 223264   138981      136   136653        0       28        0 
  2338  1205K   2782   598556 222416   332263      321   321321        0      164       30 
  3251  1204K   2919   598770 222027    90135       82    85050        0        5        0 
  2606  1203K    212   600436 224678   114502        1   112450        0       35        0 
  1188  1200K    174   600230 228582   162660      117   157230    33127      860     9914 
 22069  1200K  27612   550547 230304    89953       38    82383     8274      159     2071 
  1910  1200K    349   600071 227976    24382        0    23465     7332        1     2985 
  1164  1201K    174   600281 228423     4940        1     4046     7087        8     2500 
 30404  1203K    186   567418 229475    16087        1    16045     8566        4     2235

MacOS – How to investigate high kernel task memory usage

There are many things that go wrong with high kernel task usage. Usually this is related to faulty or heavy process which overusing system resources (such as indexing storage, running VMs, too many tabs in the web browser or some other background processes).

Here are some methods which help to investigate OS X kernel usage issues:

Basic methods

Run Console.app and check on 'All Messages' to see if anything unusual currently is happening.
Use Activity Monitor to read system memory and determine how much CPU, RAM and Disk is being used.

Alternatively run top in Terminal and hold Space to refresh - easier to find the cause problem (swapins/swapouts/disks?).
Run sudo fs_usage in Terminal to report system calls and page faults related to filesystem activity in real-time (I think this is the best option from all other). Then hit Control-C to stop it.

Action: Consider killing apps which appears frequently on the list, but you're not using them.

Learn more at: How do I debug an out-of-control “kernel_task” process?
Run sudo syscallbypid.d (or syscallbyproc.d), wait a bit, hit Control-C. Now check which process generated the most system calls in that given time (last column) and if you recognise it, consider kill it. If not, Google it and learn more about it.

Advanced methods

Use sysdiagnose command (can be triggered by hitting Shift-Control-⌥-⌘-. (period) to quickly gather system-wide diagnostic information helpful in investigating system memory/performance issues (will appear in /var/tmp) either by you or Apple guys. During analysis, try to not do anything, when done - consider uncompressing the generated file and analyse the logs.

^{See: How do you get system diagnostic files from OS X?}
Run footprint to gather detailed memory information on a per-VM-region type level and swapped bytes:
```
sudo footprint -a
```
Older version:
```
sudo footprint -all -categories -swapped -collapseSharing
```
Use spindump to profile entire system, it'll generate /tmp/spindump.txt file (including kernel and its extensions).
Use vm_stat to show virtual memory statistics. E.g.
```
vm_stat 1 # to display every second.
```
Use zprint to check information about kernel usage, it's possible by:
```
sudo zprint -t -s | head -n20
```
It'll show the most wasting kernel zones.
Use newproc.d to snoop new processes as they are executed, creatbyproc.d for files:
```
sudo newproc.d
sudo creatbyproc.d
```
Note: On newer OS X (10.11 or above) this may not work when integrity protection is enabled (check by csrutil status).
Try sar - system activity reporter which can sample and report various cumulative statistic counters maintained by the operating system.

For more useful debugging tools, check for dtrace scripts (grep dtrace /usr/bin/*). If you know the faulty process which causing the problem, you may use dtruss to debug it.

Actions

Here are some suggestions which can help you with the operating system issues.

Free up some inactive memory. In order to do this, you've to flush cache first and force disk cache to be purged:
```
sync && sudo purge
```
sync - force completion of pending disk writes (flush cache)

purge - force disk cache to be purged (flushed and emptied)

Its function is basically to terminate all the I/O pending operations which are using disk cache and then to free all the occupied disk cache, so it should free disk space to ease paging out and swapping out of main memory. It is safe to use, as it does not affect anonymous memory that has been allocated through malloc, vm_allocate, etc.
Use some 3rd party apps to clear up some overused memory such as iBoostUp, SystemPal, etc.

You may also disable temporary Spotlight:

sudo launchctl unload -w /System/Library/LaunchDaemons/com.apple.metadata.mds.plist

And consider other services by:

sudo launchctl list | grep ^[0-9]
sudo launchctl bslist | grep ^A

Quit your web browser and check if that helps. For example using Chrome is very resourceful, especially when there is some front-end processing going on in the background (e.g. Javascript) or advert-like animations are constantly rendering the content.