The cachefs_readahead parameter specifies the number of blocks to read ahead of the current read block in the filesystem. The blocks are read asynchronously.

Default: 1 (0x1)

Range: 0 - 10

The cachefs_max_threads parameter specifies the maximum number of asynchronous I/O daemons that can be run per cachefs mount.

Default: 5 (0x5)

Range: 1 - 10

The nbuf parameter specifies the number of buffer headers in the filesystem buffer cache. The actual memory associated with each buffer header is dynamically allocated as needed. The memory can be of varying size: 1 to 128 blocks (512 to 64KB) for write operations, and 1 to 1024 blocks (512 to 512KB) for read operations.

The system uses the filesystem buffer cache to optimize filesystem I/O requests. The buffer memory caches blocks from the disk, and the blocks that are used frequently stay in the cache. This helps avoid excess disk activity.

Buffers are used only as transaction headers. When the input or output operation has finished, the buffer is detached from the memory it mapped and the buffer header becomes available for other uses. Because of this, a small number of buffer headers is sufficient for most systems. If nbuf is set to 0, the system automatically configures nbuf for average systems. There is little overhead in making it larger for non-average systems.

The nbuf parameter is defined in /var/sysgen/mtune.

Default: 0 (Automatically configured if set to 0)

Formula:

32-bit kernels: min(100 + (KiloBytes of memory) / 160, 6000)

64-bit kernels: min(100 + (KiloBytes of memory) / 160, 600000)

The automatic configuration is adequate for average systems. If you see dropping cache-hit rates in sar and osview output, increase this parameter. Also, if you have directories with a great number of files (over 1000), you may wish to raise this parameter.

The recommended initial value for large (64 processors or greater) systems is 2000.

The  min_bufmem parameter specifies the minimum amount of memory held by filesystem metadata that is cached in the buffer cache when the system runs into low memory conditions. This is expressed in pages of memory.

Default: two percent of physical memory

Change this value when there is a high I/O load on your machine but you still need to access directory information quickly.

The callout_himark parameter specifies the maximum number of callout table entries system-wide. The callout table is used by device drivers to provide a timeout to make sure that the system does not hang when a device does not respond to commands.

This parameter is defined in /var/sysgen/mtune and has the following formula:

nproc + 32

where:

nproc is the maximum number of processes, system-wide.

Default: 0 (Automatically configured if set to 0)

Formula: nproc + 32

Range: 42 - 1100

Increase this parameter if you see console error messages indicating that no more callouts are available.

The ncallout parameter specifies the number of callout table entries at boot time. The system will automatically allocate one new callout entry if it runs out of entries in the callout table. However, the maximum number of entries in the callout table is defined by the callout_himark parameter.

Default: 40

Range: 20–1000

Update ncallout if you are running an unusually high number of device drivers on your system. Note that the system automatically allocates additional entries when needed, and releases them when they are no longer needed.

The reserve_ncallout parameter specifies the number of reserved callout table entries. These reserved table entries exist for kernel interrupt routines when the system has run out of the normal callout table entries and cannot allocate additional entries.

Default: 5

Range: 0-30

The ncsize parameter controls the size of the name cache. The name cache is used to allow the system to bypass reading directory names out of the main buffer cache. A name cache entry contains a directory name, a pointer to the directory's in-core inode and version numbers, and a similar pointer to the directory's parent directory in-core inode and version number.

Default: 0 (Automatically configured if set to 0)

Range: 268-1M

The ndquot parameter controls disk quotas.

Default: 0 (Automatically configured if set to 0)

Range: 268-6200

The nproc parameter specifies the number of entries in the system process (proc) table. Each running process requires an in-core proc structure. Thus, nproc is the maximum number of processes that can exist in the system at any given time.

The default value of nproc is based on the amount of memory on your system. To find the currently auto-configured value of nproc, use the systune command.

The nproc parameter is defined in /var/sysgen/mtune.

Default: 0 (Automatically configured if set to 0)

Range: 30-1M

Increase this parameter if you see an overflow in the sar -v output for the proc -sz ov column or you receive the operating system message:

no more processes

This means that the total number of processes in the system has reached the current setting. If processes are prevented from forking (being created), increase this parameter. A related parameter is maxup.

The recommended initial value for large (64 processors or greater) systems is 8000.

If a process cannot fork, make sure that this is system-wide and not just a user ID problem (see the maxup parameter).

If nproc is too small, processes that try to fork receive the operating system error:

EAGAIN: No more processes

The shell also returns a message:

fork failed: too many processes

If a system daemon such as sched, vhand, init, or bdflush cannot allocate a process table entry, the system halts and displays:

No process slots

The maxpmem parameter specifies the amount of physical memory (in pages) that the system can recognize. The page size is 4 KB for 32 bit IRIX version 5 or 6 kernels and 16 KB for 64 bit IRIX version 6 kernels. If it is set to zero (0), the system will use all available pages in memory. A value other than zero defines the physical memory size (in pages) that the system will recognize.

This parameter is defined in /var/sysgen/mtune.

Default: 0 (Automatically configured if set to 0)

Range: 1024 pages—total amount of memory

You do not need to change this parameter, except when benchmarks require a specific system memory size less than the physical memory size of the system. This is primarily useful to kernel developers. You can also boot the system with this command added on the boot command line to achieve the same effect:

maxpmem = memory_size

The syssegez parameter specifies the maximum number of pages of dynamic system memory.

Default: 0 (Autoconfigured if set to 0)

32-bit Range: 0x2000 - 0x20000

64-bit Range: 0x2000 - 0x10000000

Increase this parameter correspondingly when maxdmasz is increased, or when you install a kernel driver that performs a lot of dynamic memory allocation.

The recommended initial value for large (64 processors or greater) systems is 0xfe800.

The maxdmasz parameter specifies the maximum DMA transfer expressed in pages of memory. This amount must be less than the value of syssegsz and maxpmem.

Default: 1025 (32-bit kernels)

Default: 257 (64-bit kernels)

32-bit Range: 1 - syssegsz (maximum 0x20000)

64-bit Range: 1 - syssegsz (maximum 0x10000000)

Change this parameter when you need to be able to use very large read or write system calls, or other system calls that perform large scale DMA. This situation typically arises when using optical scanners, film recorders or some printers.

Note that the actual DMA transfer size is one less page than the number of pages set in this parameter. Thus, to allow a full DMA transfer of 16 MB (1024 pages), set this parameter to 1025.

The recommended initial value for large (64 processors or greater) systems is 0x2001.

The mbmaxpages parameter specifies the maximum number of single page clusters that can be allocated to network buffers. This limits the total memory that network buffers (mbufs) can consume.

Default: 1/4 of physical memory

Range: Default - Total System Memory (in pages)

For most workstations and small servers the default is sufficient. For very large systems, larger values are appropriate. A 0 value tells the kernel to set the value (1/4 of physical memory) based on the amount of physical memory configured in the hardware.

The minimum that can be set with the systune command is 16 pages. The maximum is 8192 pages for 32-bit systems and 2097152 pages for 64-bit systems.

The ecc_recover_enable parameter, when set to 0, directs the system not to attempt to recover from multibit errors. If it is set greater than 0, the parameter value is taken as a number of seconds. The system is directed to attempt recovery, but not in the event of more than 32 errors in each number of seconds specified by this parameter.

Default: 60 seconds (0x3c)

utraces are a lightweight tracing mechanism used to collect kernel debugging information. The utrace_bufsize parameter selects the number of 48 byte utrace entries stored for each CPU. Setting this parameter to 0 disables trace collection. Only buffer sizes of 0 and 2048 are supported.

Default: 0

Range: 0-0x7fffffff

The dump_level parameter specifies the dump level and controls the data dumped in a system crash. Setting this parameter to 0 dumps only putbuf,errbuf, and low memory during a panic. 1 also dumps static, dynamic, and backtrace kernel pages along with pfdats (if applicable); 2 also dumps buffer cache pages; 3 also dump remaining in-use pages; and 4 also dumps free pages.

Default: 0

Range: 0-4

The recommended initial value for large (64 processors or greater) systems is 3.

The buf_relse_age parameter specifies when a buffer cache page needs to be released. If a file's data had been untouched for at least buf_relse_age seconds, then the data is released.

This run-time settable variable may be useful in systems in which some nodes have plenty of free memory and others have consumed all local memory. If the latter contains a lot of very aged buffer cache data, the normal buffer releasing system may not release the data because the system looks at memory globally and does not distinguish memory per node.

Default: 0 (0 means the feature is not used.)

Range: 0-0x7fffffff seconds

A recommended setting is difficult to provide as the load and needs of every system are different. Any setting under 30 seconds is too aggressive, and any under 10 seconds causes a lot of thrashing.

A workable solution is to set buf_relse_age to 600 seconds (5 minutes), to study the displays of the bufview and osview commands over time in order to observe how much memory is available, and then to adjust the buf_relse_age value up or down until it appears to be satisfactory.

The maxup parameter defines the number of processes allowed per user login. This value should always be at least 20 less than nproc.

Default: 150 processes

Range: 15–30000 (but never more than nproc minus 20)

Increase this parameter to allow more processes per user. In a heavily loaded time-sharing environment, you may want to decrease the value to reduce the number of processes per user.

The recommended initial value for large (64 processors or greater) systems is 8000.

The ngroups_max parameter specifies the maximum number of multiple groups to which a user may simultaneously belong.

The constants NGROUPS_UMIN <= ngroups_max <= NGROUPS_UMAX are defined in </usr/include/sys/param.h>. NGROUPS_UMIN is the minimum number of multiple groups that can be selected at lboot time. NGROUPS_UMAX is the maximum number of multiple groups that can be selected at lboot time and is the number of group-id slots for which space is set aside at compile time. NGROUPS, which is present for compatibility with networking code (defined in </usr/include/sys/param.h>), must not be larger than ngroups_max.

Default: 16

Range: 0-32

The default value is adequate for most systems. Increase this parameter if your system has users who need simultaneous access to more than 16 groups.

The maxwatchpoints parameter sets the maximum number of watchpoints per process. Watchpoints are set and used via the proc(4) filesystem. This parameter specifies the maximum number of virtual address segments to be watched in the traced process. This is typically used by debuggers.

Default: 100

Range: 1-1000

Raise maxwatchpoints if your debugger is running out of watchpoints.

The nprofile parameter specifies the maximum number of disjoint text spaces that can be profiled using the sprofil(2) system call. This is useful if you need to profile programs using shared libraries or profile an address space using different granularities for different sections of text.

Default: 100

Range: 100-10000

Change nprofile if you need to profile more text spaces than are currently configured.

The maxsymlinks parameter defines the maximum number of symbolic links that will be followed during filename lookups (for example, during the open(2) or stat(2) system calls) before ceasing the lookup. This limit is required to prevent loops where a chain of symbolic links points back to the original filename.

Default: 30

Range: 0-50

Change this parameter if you have pathnames with more than 30 symbolic links.

The ncargs parameter specifies the maximum size of arguments in bytes that may be passed during an exec(2) system call.

This parameter is specified in /var/sysgen/mtune.

Default: 20480

Range: 5120–262144

The default value is adequate for most systems. Increase this parameter if you get the following message from exec(2), shell(1), or make(1):

E2BIG arg list too long

Setting this parameter too large wastes memory (although this memory is pageable) and may cause some programs to function incorrectly. Also note that some shells may have independent limits smaller than ncargs.

The rlimit_core_cur parameter specifies the current limit to the size of core image files for the given process.

Default: 0x7fffffffffffffff (9223372036854775807 bytes)

Range: 0–0x7fffffffffffffff

Change this parameter when you want to place a cap on core file size.

The rlimit_core_max parameter specifies the maximum limit to the size of core image files.

Default: 0x7fffffffffffffff (9223372036854775807 bytes)

Range: 0–0x7fffffffffffffff

Change this parameter when you want to place a maximum restriction on core file size. rlimit_core_cur cannot be larger than this value.

The rlimit_cpu_cur parameter specifies the current limit to the amount of CPU time in seconds that may be used in executing the process.

Default: 0x7fffffffffffffff (9223372036854775807 seconds)

Range: 0–0x7fffffffffffffff

Change this parameter when you want to place a cap on CPU usage.

The rlimit_cpu_max parameter specifies the maximum limit to the amount of CPU time that may be used in executing a process.

Default: 0x7fffffffffffffff (9223372036854775807 minutes)

Range: 0–0x7fffffffffffffff

Change this parameter when you want to place a maximum restriction on general CPU usage.

The rlimit_data_cur parameter specifies the current limit to the data size of the process.

Default: 0 (auto-configured to rlimit_vmem_cur * NBPP) (0x20000000)

Range: 0–0x7fffffffffffffff

Change this parameter when you want to place a cap on data segment size.

The recommended initial value for large (64 processors or greater) systems is 0 ll.

The rlimit_data_max parameter specifies the maximum limit to the size of data that may be used in executing a process.

Default: 0 (auto-configured to rlimit_vmem_cur * NBPP) (0x20000000)

Range: 0–0x7fffffffffffffff

Change this parameter when you want to place a maximum restriction on the size of the data segment of any process.

The recommended initial value for large (64 processors or greater) systems is 0 ll.

The rlimit_fsize_cur parameter specifies the current limit to file size on the system for the process.

Default: 0x7fffffffffffffff (9223372036854775807 bytes)

Range: 0–0x7fffffffffffffff

Change this parameter when you want to place a limit on file size.

The rlimit_fsize_max parameter specifies the maximum limit to file size on the system.

Default: 0x7fffffffffffffff (9223372036854775807 bytes)

Range: 0–0x7fffffffffffffff

Change this parameter when you want to place a maximum size on all files.

The rlimit_nofile_cur parameter specifies the current limit to the number of open file descriptors that may be used in executing the process.

Default: 200

Range: 40–0x7fffffffffffffff

Change this parameter when you want to place a cap on the number of open file descriptors.

The rlimit_nofile_max parameter specifies the maximum limit to the number of open file descriptors that may be used in executing a process.

Default: 2500

Range: 0–0x7fffffffffffffff

Change this parameter when you want to place a maximum restriction on the number of open file descriptors.

The rlimit_pthread_cur parameter specifies the current amount of threads that a process creates.

Default: 1024 (0x400)

The rlimit_pthread_max parameter specifies the maximum value rlimit_pthread_cur may hold.

Default: 1024 (0x400)

The rlimit_rss_cur parameter specifies the current limit to the resident set size (the number of pages of memory in use at any given time) that may be used in executing the process. This limit is the larger of the results of the following two formulae:

physical_memory_size - 4 MB

physical_memory_size * 9/10

Default: 0. If rlimit_rss_cur is 0, it is automatically configured to the larger of the following formulae:

  physical_memory_size - 4 MB
  physical_memory_size * 9/10)

Range: 0–0x7fffffffffffffff

Change this parameter when you want to place a cap on the resident set size of a process.

The recommended initial value for large (64 processors or greater) systems is 0 ll.

The rlimit_rss_max parameter specifies the maximum limit to the resident set size that may be used in executing a process.

Default: 0. If rlimit_rss_max is 0, it is automatically configured to the larger of the following formulae:

  physical_memory_size - 4 MB
  physical_memory_size * 9/10)

Range: 0–0x7fffffffffffffff

Change this parameter when you want to place a maximum restriction on resident set size.

The recommended initial value for large (64 processors or greater) systems is 0 ll.

The rlimit_stack_cur parameter specifies the current limit to the amount of stack space that may be used in executing the process.

Default: 64 MB (0x04000000)

Range: 0–0x7fffffffffffffff)

Change this parameter when you want to place a limit on stack space usage.

The recommended initial value for large (64 processors or greater) systems is (0x04000000) ll.

The rlimit_stack_max parameter specifies the maximum limit to the amount of stack space that may be used in executing a process.

Default: rlimit_vmem_cur * NBPP (0x20000000)

Range: 0–0x7fffffffffffffff

Change this parameter when you want to place a maximum restriction on stack space usage.

The recommended initial value for large (64 processors or greater) systems is (0x20000000) ll.

The rlimit_vmem_cur parameter specifies the current limit to the amount of virtual memory that may be used in executing the process.

Default: 0. If rlimit_vmen_cur is 0, it is automatically configured to the following:

  0x7fffffffffffffff for Origin 3000, Origin 2000, Challenge, O200, and Onyx2 systems

  0x80000000 for Indgio 2, Power Indgio 2, Octane, and O2 systems

 0x40000000 for smaller systems

Range: 0–0x7fffffffffffffff

Change this parameter when you want to place a cap on virtual memory usage.

The recommended initial value for large (64 processors or greater) systems is 0 ll.

The rlimit_vmem_max parameter specifies the maximum limit to the amount of virtual memory that may be used in executing a process.

Default: 0. If rlimit_vmen_max is 0, it is automatically configured to the following:

  0x40000000 for smaller machines

  0x80000000 for larger machines

  0x7fffffffffffffff for the SN architecture

Range: 0–0x7fffffffffffffff

Change this parameter when you want to place a maximum restriction on virtual memory usage or if your swap space is larger than the current parameter value.

The recommended initial value for large (64 processors or greater) systems is 0 ll.

The rsshogfrac parameter specifies the percentage of memory allotted for resident pages.

The number of physical memory pages occupied by a process at any given time is called its resident set size (RSS). The limit to the RSS of a process is determined by its allowable memory-use resource limit. rsshogfrac is designed to guarantee that even if one or more processes are exceeding their RSS limit, some percentage of memory is always kept free so that good interactive response is maintained. The percentage of total memory hogged is 100% minus rsshogfrac times maximum memory or 100 MB, whichever is less.

Processes are permitted to exceed their RSS limit until either of the following occur:

Default: 75% of total memory

Range: 0–100% of total memory

The default value is adequate for most systems.

The recommended initial value for large (64 processors or greater) systems is 99.

The rsshogslop parameter specifies the number of pages above the resident set maximum that a process may use. To avoid thrashing (a condition where the computer devotes 100% of its CPU cycles to swapping and paging), a process can use up to rsshogslop more pages than its resident set maximum (see “ Resource Limits Parameters”).

This parameter is specified in /var/sysgen/mtune. For more information, see the rsshogfrac resource limit.

Default: 20

The default value is adequate for most systems.

The shlbmax parameter specifies the maximum number of shared libraries with which a process can link.

This parameter is specified in /var/sysgen/mtune.

Default: 8

Range: 3–32

The default value is adequate for most systems. Increase this parameter if you see the following message from exec(2):

ELIBMAX cannot link

The cpulimit_gracetime parameter establishes a grace period for processes that exceed the cpu time limit. It is the number of seconds that a process is allowed to run after exceeding the limit set in the rlimit_cpu_cur parameter. When cpulimit_gracetime is not set (that is, it is zero), any process that exceeds either the process or job cpu limit is sent a SIGXCPU signal. The kernel continues to send SIGXCPU signals periodically as long as that process continues to execute. Since a process can register to handle SIGXCPU, the process can effectively ignore the CPU limit.

If cpulimit_gracetime is set to a nonzero value via the systune(1M)command, the behavior changes. The kernel sends a SIGXCPU signal to a process one time when it exceeds the process cpu limit. The process can register for this signal and then perform any needed cleanup and shutdown operations. If the process is still running after accruing cpulimit_gracetime more seconds of cpu time, the kernel terminates the process with a SIGKILL signal.

Default: 0

Range: 0-86400 (seconds)

The recommended initial value is site dependent.

The bdflushr parameter specifies how many buffers will be examined each time bdflush runs; bdflush performs periodic flushes of dirty filesystem buffers. It is parallel and similar to vfs_syncr. The bdflush daemon runs once per second.

This parameter is specified in /var/sysgen/mtune. For more information, see the autoup kernel parameter.

Default: 5

Range: 1–31536000

The default value is adequate for most systems.

The gpgsmsk parameter specifies the mask used to determine if a given page may be swapped. Whenever the pager (vhand) is run, it decrements software reference bits for every active page. When a process subsequently references a page, the counter is reset to the limit (NDREF, as defined in /usr/include/sys/immu.h). When the pager is looking for pages to steal back (if memory is in short supply), it takes only pages whose reference counter has fallen to gpgsmsk or below.

This parameter is specified in /var/sysgen/mtune.

Also see /usr/include/sys/immu.h and /usr/include/sys/tuneable.h and the gpgshi and gpgslo kernel parameters for more information.

Default: 2

Range: 0–7

This value is adequate for most systems.

If the value is greater than 4, pages are written to the swap area earlier than they would be with the default value of gpgsmsk. Thus swapping/paging may occur before it should, unnecessarily using system resources.

When the vhand daemon (page handler) is stealing pages, it stops stealing when the amount of free pages is greater than gpgshi.

In other words, vhand starts stealing pages when there are fewer than gpgslo free pages in the system. Once vhand starts stealing pages, it continues until there are gpgshi pages.

If, at boot time, gpgslo and gpgshi are 0, the system sets gpgshi to 8% of the number of pages of memory in the system, and sets gpgslo to one half of gpgshi.

This parameter is specified in /var/sysgen/mtune. For more information, see the kernel parameters gpgsmsk and gpgslo.

Default: 0 (automatically configured to 8% of memory if set to 0)

Range: 30 pages – 1/2 of memory

This value is adequate for most systems.

The recommended initial value for large (64 processors or greater) systems is 2000.

If this parameter is too small, vhand cannot supply enough free memory for system-wide demand.

When the vhand daemon (page handler) executes, it would not start stealing back pages unless there are fewer than gpgslo free pages in the system. Once vhand starts stealing pages, it continues until there are gpgshi pages.

This parameter is specified in /var/sysgen/mtune. For more information, see the gpgshi and gpgsmsk kernel parameters.

Default: 0 (automatically configured to half of gpgshi if set to 0)

Range: 10 pages – 1/2 of memory

This value is adequate for most systems.

The recommended initial value for large (64 processors or greater) systems is 1000.

If this parameter is too small, vhand does not start swapping pages; thus entire processes must be swapped. If this parameter is too large, vhand swaps pages unnecessarily.

The maxlkmem parameter specifies the maximum number of physical pages that can be locked in memory (by mpin(2) or plock(2)) per non-superuser process.

This parameter is specified in /var/sysgen/mtune.

Default: 2000

Range: 0 pages – 3/4 of physical memory

Increase this parameter only if a particular application has a real need to lock more pages in memory.

On multi-user servers, you may want to decrease this parameter and also decrease rlimit_vmem_cur.

When pages are locked in memory, the system cannot reclaim those pages, and therefore cannot maintain the most efficient paging.

The maxfc parameter specifies the maximum number of pages that may be freed by the vhand daemon in a single operation. When the paging daemon (vhand) starts stealing pages, it collects pages that can be freed to the general page pool. It collects, at most, maxfc pages at a time before freeing them. Do not confuse this parameter with gpgshi, which sets the total number of pages that must be free before vhand stops stealing pages.

This parameter is specified in /var/sysgen/mtune.

Default: 100

Range: 50–100

This value is adequate for most systems.

The maxsc parameter specifies the maximum number of pages that may be swapped by the vhand daemon in a single operation. When the paging daemon starts tossing pages, it collects pages that must be written out to swap space before they are actually swapped and then freed into the general page pool. It collects at most maxsc pages at a time before swapping them out.

This parameter is specified in /var/sysgen/mtune.

Default: 100

Range: 8–100

You may want to decrease this parameter on systems that are swapping over NFS ( Network File System). This is always the case for diskless systems to increase performance.

The maxdc parameter is the maximum number of pages which can be saved up and written to the disk at one time.

Default: 100 pages

Range: 1-100

If the system is low on memory and consistently paging out user memory to remote swap space (for example, mounted via NFS), decrease this parameter by not more than ten pages at a time. However, this parameter's setting does not usually make any measurable difference in system performance.

The minarmem parameter represents the minimum available resident memory that must be maintained in order to avoid deadlock.

Default: 0 (Autoconfigured if set to 0)

The automatically configured value of this parameter should always be correct for each system. You should not have to change this parameter.

The minasmem parameter represents the minimum available swappable memory that must be maintained in order to avoid deadlock.

Default: 0 (Autoconfigured if set to 0)

The automatically configured value of this parameter should always be correct for each system. You should not have to change this parameter.

The numa_paging_node_freemem_low_threshold parameter specifies when to trigger a global system memory accounting procedure to check if vhand should be started.

Default: 40

The scache_pool_size parameter specifies the amount of memory always kept in reserve for use by the paging daemon. The value is the number of kilobytes reserved, which is always rounded up to the next page boundary.

Default: 32

Use caution when changing this parameter. Setting it too low will result in memory deadlocks. Setting it too high will waste memory. If the system panics with the message scache... out of memory, then this parameter should be increased. Otherwise, you should not have to change this parameter.

The tlbdrop parameter specifies the number of clock ticks before a process's wired entries are flushed.

Default: 100

If sar indicates a great deal of transaction lookaside buffer (utlbmiss) overhead in a very large application, you may need to increase this parameter. In general, the more the application changes the memory frame of reference in which it is executing, the more likely increasing tlbdrop will help performance. You may have to experiment somewhat to find the optimum value for your specific application.

The vfs_syncr parameter specifies the number of seconds between runs of the vfs_syncr process.

Default: 30

Range: 1 - 31536000 (1 year)

Under normal circumstances it is not necessary to change this parameter.

The maxpglst parameter specifies the maximum number of pages that can be held in each of the pager's pageout queues.

Default: 0 (Autoconfigured)

Range: 50 - 1000

The zone_accum_limit parameter specifies the percentage of memory (in a node on a NUMA system) that can be accumulated before shaked is kicked off to shake the zone of free memory back into the global pool. This parameter is set to 30%, which means if the amount of free memory kept in zones exceeds 30%, shaked is kicked off.

Default: 30

Range: 0 - 100

The percent_totalmem_64k_pages parameter specifies the percentage of total memory that can be used as an upper limit for the number of 64 KB pages.

Default: 0

Range: 0-100 (%)

Set dynamically to get 64 KB pages.

The recommended initial value for large (64 processors or greater) systems is 0.

---

Note: Other possible values are discussed in “Multiple Page Sizes” in Chapter 10.

---

The nlpages_64k parameter is used to reserve 64 KB pages at boot time. This increases the probability of getting large pages in a low memory system.

Default: 0

Range: 0-memory_size/64*1024, where memory_size is the total amount of memory in the system.

Not recommended unless absolutely necessary.

---

Note: Other possible values are discussed in “Multiple Page Sizes” in Chapter 10.

---

The msgmax parameter specifies the maximum size of a message.

This parameter is specified in /var/sysgen/mtune/msg.

Default: 16 * 1024 (0x4000)

Range: 512-0x8000

Increase this parameter if the maximum size of a message needs to be larger. Decrease the value to limit the size of messages.

The msgmnb parameter specifies the maximum length of a message queue.

This parameter is specified in /var/sysgen/mtune/msg.

Default: 32 * 1024 (0x8000)

Range: msgmax–1/2 of physical memory

Increase this parameter if the maximum number of bytes on a message queue needs to be longer. Decrease the value to limit the number of bytes per message queue.

The msgmni parameter specifies the maximum number of message queues system-wide.

This parameter is specified in /var/sysgen/mtune/msg.

Default: 50

Range: 10–1000

Increase this parameter if you want more message queues on the system. Decrease the value to limit the message queues.

If there are not enough message queues, a msgget(2) system call that attempts to create a new message queue returns the error:

ENOSPC: No space left on device

The msgseg parameter specifies the maximum number of message segments system-wide. A message on a message queue consists of one or more of these segments. The size of each segment is set by the msgssz parameter.

This parameter is specified in /var/sysgen/mtune/msg.

Default: 1536

Modify this parameter to reserve the appropriate amount of memory for messages. Increase this parameter if you need more memory for message segments on the system. Decrease the value to limit the amount of memory used for message segments.

If this parameter is too large, memory may be wasted (saved for messages but never used). If this parameter is too small, some messages that are sent will not fit into the reserved message buffer space. In this case, a msgsnd(2) system call waits until space becomes available.

The msgssz parameter specifies the size, in bytes, of a message segment. Messages consist of a contiguous set of message segments large enough to accommodate the text of the message. Using segments helps to eliminate fragmentation and speed the allocation of the message buffers.

This parameter is specified in /var/sysgen/mtune/msg.

Default: 8

This parameter is set to minimize wasted message buffer space. Change this parameter only if most messages do not fit into one segment with a minimum of wasted space.

If you modify this parameter, you may also need to change the msgseg parameter.

If this parameter is too large, message buffer space may be wasted by fragmentation, which in turn may cause processes that are sending messages to sleep while waiting for message buffer space.

The msgtql parameter specifies the maximum number of message headers system-wide, and thus the number of outstanding (unread) messages. One header is required for each outstanding message.

This parameter is specified in /var/sysgen/mtune/msg.

Default: 40

Range: 10–4000

Increase this parameter if you require more outstanding messages. Decrease the value to limit the number of outstanding messages.

If this parameter is too small, a msgsnd(2) system call attempting to send a message that would put msgtql over the limit waits until messages are received (read) from the queues.

The semmni parameter specifies the maximum number of semaphore identifiers in the kernel. This is the number of unique semaphore sets that can be active at any given time. Semaphores are created in sets; there may be more than one semaphore per set.

This parameter is specified in /var/sysgen/mtune/sem.

Default: 300

Increase this parameter if processes require more semaphore sets. Increasing this parameter to a large value requires more memory to keep track of semaphore sets. If you modify this parameter, you may need to modify other related parameters.

The recommended initial value for large (64 processors or greater) systems is 2000.

The semmsl parameter specifies the maximum number of semaphores per semaphore identifier.

This parameter is specified in /var/sysgen/mtune/sem.

Default: 100

Increase this parameter if processes require more semaphores per semaphore identifier.

The semopm parameter specifies the maximum number of semaphore operations that can be executed per semop() system call. This parameter permits the system to check or modify the value of more than one semaphore in a set with each semop() system call.

This parameter is specified in /var/sysgen/mtune/sem.

Default: 100

Change this parameter to increase/decrease the number of operations permitted per semop() system call. You may need to increase this parameter if you increase semmsl (the number of semaphore sets), so that a process can check/modify all the semaphores in a set with one system call.

The semvmx parameter specifies the maximum value that a semaphore can have.

This parameter is specified in /var/sysgen/mtune/sem.

Default: 32767 (maximum value)

Decrease this parameter if you want to limit the maximum value for a semaphore.

The semaem parameter specifies the adjustment on exit for maximum value, alias semadj. This value is used when a semaphore value becomes greater than or equal to the absolute value of semop(2), unless the program has set its own value.

This parameter is specified in /var/sysgen/mtune/sem.

Default: 16384 (maximum value)

Change this parameter to decrease the maximum value for the adjustment on exit value.

The shmmax parameter specifies the maximum size in bytes of an individual shared memory segment.

This parameter is specified in /var/sysgen/mtune/kernel.

Default: 0

32-bit Range: 0x1000 - 0x7fffffff

64-bit Range: 0x1000 - 0x7fffffffffffffff ll

If the value of shmmax is 0, it will be adjusted to be 80% of the system memory size at boot time. If the default value specifies a number, kernel will obey that.

Keep this parameter small if it is necessary that a single shared memory segment not use too much memory.

The recommended initial value for large (64 processors or greater) systems is (0x4000000) 11.

The shmmin parameter specifies the minimum size in bytes of a shared memory segment.

This parameter is specified in /var/sysgen/mtune/kernel.

Default: 1 byte

Range: 1

Increase this parameter if you want an error message to be generated when a process requests a shared memory segment that is too small.

The shmmni parameter specifies the maximum number of shared memory segments system-wide.

This parameter is specified in /var/sysgen/mtune/kernel.

Default: 0

Range: 5–100000

If shmmni default value is 0, it will be adjusted at boot time to be the same value as the nproc tunable variable. If the default value specifies a number, kernel will obey that.

Increase this parameter by one (1) for each additional shared memory segment that is required, and also if processes that use many shared memory segments reach the shmmni limit.

Decrease this parameter if you need to reduce the maximum number of shared memory segments of the system at any one time. Also decrease it to reduce the amount of kernel space taken for shared memory segments.

The sshmseg parameter specifies the maximum number of attached shared memory segments per process. A process must attach a shared memory segment before the data can be accessed.

This parameter is specified in /var/sysgen/mtune/kernel.

Default: 2000

Range: 1–10000

Increase this parameter if processes need to attach more than the default number of shared memory segments at one time.

The nstrpush parameter defines the maximum number of streams modules that can be pushed on a single stream.

Default: 9 (0x9)

Range: 9-10

Change nstrpush from 9 to 10 modules when you need an extra module.

The nstrintr parameter defines the streams buffers used at interrupt time.

Default: 1024 (0x400)

Range: 32-4096

The strctlsz parameter is the maximum size of the ctl buffer of a streams message. See the getmsg(2) or putmsg(2) man pages for a discussion of the ctl and data parts of a streams message.

Default: 1024 (0x400)