Memory Limitations for OptiStruct




32-bit Versus 64-bit Computations

On 32-bit operating systems, OptiStruct can, in most cases, make use of no more than 2.0 GB of memory (depending on the operating system and other software installed on the system, this limit is often lower). The typical memory limit for Windows is 1.7 - 1.8 GB, but can be as low as 1.5 GB. Note that use of 64-bit hardware (EM64T or AMD64: 64-bit capable CPU) does not affect this limit.

On certain 32-bit operating systems, OptiStruct can benefit in a limited way from additional physical memory (above 2GB RAM) in a number of ways:

  1. The operating system and other programs running alongside OptiStruct (HyperMesh, for example) can make use of the additional memory.

  2. OptiStruct requires that its memory be allocated in one continuous chunk. The main exception is when it launches a bandwidth minimizer which requires an additional small amount of memory. On Windows platforms, the additional memory used by the bandwidth minimizer may be allocated above the 2GB limit, thus allowing the solution of slightly bigger jobs. In order to allow this, Windows must be started with the "/3GB" switch in the 'boot.ini' file. This option is available on most versions of Windows 2000, and Windows XP (requires SP2 on XP), but it is not 'officially' documented by Microsoft because on some hardware configurations it can cause unexpected crashes. In any case, the /3GB switch does not increase the amount of continuous memory allocation, thus it only marginally helps in solving large problems.

  3. A 32-bit Linux operating system is the only one which allows more than 2GB runs. On most versions of Linux, OptiStruct can allocate about 2.2 GB (if available). In some cases, rebuilding the Linux kernel with special flags for large memory usage can increase this value to about 3 GB. Some kernels have been preconfigured this way (RHEL 3.0, for example). In general, if you use kernal 2.4 or older, you should upgrade to a newer version of Linux. The newest kernal 2.6 (e.g. on Fedora Core 2 and newer, RHEL 4.0) allows up to 4 GB of RAM for each task. Consult your Linux documentation to find what specific options may be available. Linux command ‘uname -a’ will show the kernal version.

On 64-bit machines, when using a 64-bit compiled version of OptiStruct and a 64-bit operating system, theoretically, up to 32 GB of memory can be used. Depending on the particular solution sequence, OptiStruct may not be able to utilize all 32 GB RAM (if assigned using the –fixlen option), so it is best to allow automatic memory allocation and to use the correct value for the –len option (see below). For example; for static analysis cases, the limit is 16 GB. For normal modes analysis cases, the limit is 8 GB.

OptiStruct automatically takes into account all internal memory limits and tries to use as much memory as possible if it makes sense. When printing estimates for the memory usage, OptiStruct does not show results if they exceed these limits (irrespective of the amount of memory actually available – thus, if there is not estimate for memory requirements for in-core solution, this means that OptiStruct will not be able to solve in-core, even on the computer with unlimited memory).

Virtual Versus Physical Memory

OptiStruct can use more memory than is actually installed on a given system (i.e. more than the installed RAM). This is what the virtual memory (swap space) is for. OptiStruct is more efficient, however, if it uses only actual RAM (remember to allow some RAM to be used by the operating system and other codes running at the same time). When more memory is requested than actual available RAM, OptiStruct will run much slower due to swapping. You will hear disks working constantly with little CPU being used, and there will be a significant difference between the elapsed time and the CPU time.

Memory specification for OptiStruct (using –len command line option) is actually only giving OptiStruct a hint about the amount of physical RAM available for the run (i.e. it should specify the amount of physical memory not used by the operating system and other running programs, and as explained above, always less than the total amount of RAM in the computer). Based on this information, OptiStruct will automatically determine if in-core run is desirable and switch to out-of-core, or even minimum-core mode, if needed. Note that if minimum-core run requires more memory than indicated by -len option, then OptiStruct will not be limited by this value and will try to use as much memory as needed. In other words, it is incorrect to overestimate memory size for -len option – it will not help run larger jobs, and may actually slow down turnaround time because of excessive swapping.

Automatic Memory Allocation Versus Fixed Memory Runs

In standard modes of operation, OptiStruct automatically estimates the amount of memory required, and this memory is requested in successive steps from the operating system. Sometimes the memory could be used more efficiently if requested at once and not in increments (especially on 32-bit operating systems). This can be done using the "-fixlen" command line option (see Options for Running OptiStruct). When using the "-fixlen" option, OptiStruct may start to run, but fail after some time with a memory allocation error. This can happen when almost all available memory is requested by the "-fixlen" argument, because in addition to the memory required by the OptiStruct solver, OptiStruct launches a bandwidth minimizer, which uses an additional small amount of memory. Requesting slightly less memory with the "-fixlen" option is a possible solution. Again, we see that it is incorrect to assign too much memory to OptiStruct.

Return to Altair HyperWorks Index