INtime® 3.1 Software - tenAsys

INtime 3.1 Software
If a distinct thread drives each client, an efficient transaction system requires that
threads share access to database data. When threads run concurrently, this situation
ocasionally arises:
Figure 4-6. Multithreading and mutual exclusion
B
A
Thread A, the running thread, reads data from the database and performs computations based
on the data.
Thread B tries to preempt thread A and update the data while thread A works on it. Mutual
exclusion, provided by a region, prevents two threads from accessing the same data concurrently.
Unless thread B is prevented from modifying the data until after thread A has finished,
thread A may unknowingly use some old data and some new data, resulting in an
invalid computation. It should, however, read and compute the new data after thread B
updates it.
Memory pools and memory sharing
Memory pools are the basis of INtime software’s memory management. Two types of
memory pools exist:
• Initial memory pool: All the memory available to the RT kernel (that is, free space
memory). Managed by the RT kernel, the initial memory pool belongs to the root
process and is allocated to INtime applications on request. Any amount of memory
you allocate to the RT kernel is not available to Windows for that session. There is
a practical maximum for the amount of memory allocated to INtime software. This
value depends on the number and size of INtime applications that run on the
RT kernel.
• Process memory pools: A portion of the initial memory pool assigned to an INtime
application process when that process is created. Each process memory pool has a
minimum and a maximum size. Once the minimum memory is allocated to a
process, that memory is not available to other processes. When you delete a
process, its memory returns to the initial memory pool.
As threads in a process create and delete objects, the process memory pool’s size
increases and decreases as needed, provided minimum and maximum values
are not yet encountered. This provides dynamic memory allocation of the
memory pool.
48