Generally the most common performance problems are related to Out Of
Memory errors. Out Of Memory errors can occur at any location in the code,
therefore, you need to eliminate those in order to determine if there are any
separate issues.
To begin troubleshooting for Out of Memory errors, do the following:
- Open the AgilePoint Server
Configuration and reduce the Thread Pool Size to (e.g. 50) and the Database
Connection Pool Size to (e.g. 100). If that doesn't eliminate the Out Of Memory
errors, try reducing the sizes even further. Remember that increasing pool and
queue sizes to increase multithreading only improves performance up to the
point that the server's hardware can support the concurrent processing. Beyond
that, it becomes detrimental to both performance (and potentially to server
stability).
- Examine what other
applications are running on the server and try to free up as much of the
server's memory as possible for AgilePoint's use.
- Ensure there are no other
applications using the Application Pool for AgilePoint Server.
- Out Of Memory errors could
be due to an overloaded Database server, poor network performance, or other
reasons. Check the Database server's stability and logs to see if anything is
wrong with it. If the Database server is a performance bottleneck, it could
potentially cause in-process work to build up on the AgilePoint server. To
resolve this issue, try moving from a 32-bit to 64-bit server, this will also
enable the advantages of table partition.
- If the above steps don't
resolve the Out Of Memory errors, try increasing the amount of physical memory,
move from 32-bit to 64-bit server, or change other server configuration
settings to prevent the server from becoming overloaded.
An expired trial license could also cause problems, because it may have
caused a large amount of work to build up waiting for server processing. Once
the key was replaced, if the server tries to concurrently process too much work
(because of the configured settings), it could potentially cause Out Of Memory
errors.
During very high load, server's may not recycle "unused" memory as
quickly as at other times, so servers that have periods of very high load and
high-memory allocation may run out of memory simply because they use up (i.e.
allocate) memory faster than the server can recycle (i.e. de-allocate) the
memory and make it available for use again.
Note: The amount of memory displayed by a Windows
process in the Windows Task Manager does not necessarily reflect the amount of
memory currently needed (or even being used) by that Windows process. If you
are trying to measure how much memory a .NET-based application is actually
using (i.e. the application's memory footprint) or allocating, you should see
one of the many tutorials available online about how to do so accurately. There
are also many products available (both commercial and free) specifically
designed to assist in memory analysis.
