CFX内存限制相关经验总结

cfx中2G内存限制
(2006-07-11 01:47:19)
转载
分类：cfx
The CFX-5 Solver requests it's necessary memory from the operating system at the beginning of the run. If it fails to do so, it will fail with the following error.
+------------------------------------------------------+
*** Run-time memory configuration error ***
Not enough free memory is currently available on the system.
Could not allocate requested memory - exiting!
+------------------------------------------------------+
Windows workstations with large amounts of memory (>2Gb) can fail during this stage even if the total amount of requested memory is less than 2Gb. If this happens, first verify that sufficient Virtual Memory has been allocated in the Operating System. It is recommended that the maximum size of Virtual Memory be at least twice the size of the available physical memory.
Even with enough Virtual Memory, the problem may persist and is a limitation of the Windows Operating System. Under all current 32-bit Windows operating systems (Windows NT, 2000, XP), the total available address space for any process is 2Gb. If the solver is attempting to allocate more than 2Gb of memory, it will fail.
Unfortunately, even if the solver is attempting to allocate less than 2Gb of memory, it may fail.
The problem lies in the details of how Windows manages the 2Gb address space. When a Windows application loads, there are usually a number of libraries (or DLLs) that are loaded as well. These libraries are loaded into the 2Gb address space, but not in any specific order or memory location. The operating system tries to optimize the locations of the DLLs, but a certain degree of memory fragmentation does occur. When the solver tries to allocate memory, it is given the largest contiguous space in the 2Gb range. Depending on where Windows loaded the initial libraries, this may be 1.8Gb, 1.3Gb, or even less. You may be surprised to find that a 1.4Gb solver run was fine one time, but failed to allocate memory a subsequent time. This is an unfortunate side effect of Windows memory management.
If the solver fails memory allocation, but is close to the available memory, using explicit solver memory allocation may allow the case to run. When it starts, the solver estimates the amount of memory required. Depending of the details of the case, this estimation may be conservative and request more memory than is actually required (but not by more than about 10%). It is possible to override the solver memory estimate and specify the memory allocation (see the Solver section of the Solver Manager documentation for more detail). Manually decreasing the allocation may allow the memory to fit within the available contiguous space.
If you have additional parallel keys, another solution is to execute the job with a larger number of parallel partitions, even if that means having more partitions than number of CPUs. With more parallel processes, each individual process will be smaller, and at some point will fit within the process memory limitations. This is done at the expense of some solver inefficiency due to additional parallel overhead.
Finally, other operating systems such a Linux do not display this limitation and may be considered if you want to take maximum advantage of your available memory.
只有Windows有这个毛病.
与记忆（“2GB）的大量失败的Windows工作站可以在这个阶段即使请求的内存总量大于2GB少。

如果发生这种情况，首先验证有足够的虚拟内存已经在作业系统中分配。

建议虚拟内存的最大大小是至少两倍的可用物理内存大小。

即使有足够的虚拟内存，该问题可能继续存在，是一种在Windows操作系统的限制。

根据目前所有32位Windows操作系统（Windows NT中，2000，XP）中，任何进程的总的可用地址空间是2GB。

如果求解器试图分配超过2GB的内存，它将会失败。

不幸的是，即使求解器试图分配小于2GB的内存，它可能会失败。

问题在于Windows如何管理2GB的地址空间的详细信息。

当一个Windows应用程序加载，通常有一个库（或DLL）的加载以及数量。

这些库被加载到2GB
的地址空间，但不是在任何特定的顺序或内存位置。

作业系统会尝试优化了DLL 的位置，但一定程度的内存碎片不会发生。

当求解器试图分配内存，它被赋予了最大2GB的范围内连续的空间。

根据最初在Windows加载库，这可能是1.8GB 的，1.3Gb，甚至更少。

您可能会惊讶地发现一个1.4Gb求解一次运行是好的，
但没有分配内存随后的时间。

这是Windows的内存管理不幸的副作用。

如果内存分配失败求解，但已接近可用的内存，使用显式求解器内存分配可能允许的情况下运行。

当它启动时，估计求解所需的内存量。

对案件的细节不同，这可能是保守的估计，并要求超过实际需要（但超过10％未）内存。

它可以覆盖求解器记忆的估计，并指定内存分配（见更详细地规划求解Manager文档求解一节）。

手动降低可允许的内存分配，以适应在现有的连续空间。

如果您有其他平键，另一种方法是执行一个平行的分区数量较多的工作，即使这意味着有超过CPU的数量更多的分区。

随着越来越多的并行处理，每个单独的进程将是更小，适合在某个时候会在进程的内存限制。

这是在做一些额外的求解效率低下，由于并行的开销。

最后，其他的Linux操作系统，如不显示此限制，可以认为，如果你想利用您的可用内存的最大优势。