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. deallocate) the
memory and make it available for use again.
