Test Cases for the OAL Cache Test (Windows CE 5.0)
Each test case for the OAL Cache Test allocates an array of memory by using the VirtualAlloc function. The array might or might not be contiguous in memory. The test case writes and then reads values from the array, verifying that each value matches the value written to the location.
Each test case derives values to store in the array from a hash of the array index and the current iteration of the test. The test uses the iteration value so that stale data does not mask an error in the cache. With hashed values, the test does not need to set values in memory to zero before each test pass.
If a test case that calls the CeGetCacheInfo function passes, but the cache size seems incorrect, investigate further. The CeGetCacheInfo function might return incorrect information because this function queries constants in the OAL. If the CeGetCacheInfo function returns incorrect information, test cases might fail.
The following table shows test cases for the OAL Cache Test.
| Test case | Description |
|---|---|
| 200: Cache Tests Usage / Help | Displays information about the OAL Cache Test. |
| 201: Print Cache Info | Displays the information returned by the CeGetCacheInfo function. |
| Write Boundaries Read Everything (array = cache size)
210: No caching 240: Write-through cache mode 270: Write-back cache mode |
This test case searches for errors in consistency between data stored in the L1 data cache and data stored in main memory. By default, this test case runs for 10 minutes.
This test case writes data near the boundaries of the cache into an array that is the size of the L1 data cache as reported by the CeGetCacheInfo function. If the CeGetCacheInfo function reports that the size of the cache is zero, this test case uses a 4-MB array. After the test case reaches steady state, each memory access is a cache hit. The test case verifies the accuracy of write operations by reading back the data. The test case also verifies that values surrounding the changed values are not changed. This test case writes values to array indexes that surround multiples of eight. For each multiple of eight, the test case writes a value into the array at the following array indexes:
The test case then reads and verifies the values. |
| Write Boundaries Read Everything (array = twice cache size)
211: No caching 241: Write-through cache mode 271: Write-back cache mode |
This test case searches for errors in consistency between data stored in the L1 data cache and data stored in main memory. By default, this test case runs for 10 minutes.
This test case writes data near the boundaries of the cache into an array that is twice the size of the L1 data cache as reported by the CeGetCacheInfo function. If the CeGetCacheInfo function reports that the size of the cache is zero, this test case uses a 4-MB array. After the test case reaches steady state, each memory access is a cache miss. The test case verifies the accuracy of write operations by reading back the data. The test case also verifies that values surrounding the changed values are not changed. This test case writes values to array indexes that surround multiples of eight. For each multiple of eight, the test case writes a value into the array at the following array indexes:
The test case then reads and verifies the values. |
| Write Boundaries Read Everything (array = user defined)
212: No caching 242: Write-through cache mode 272: Write-back cache mode |
This test case searches for errors in consistency between data stored in the L1 data cache and data stored in main memory. By default, this test case runs for 10 minutes.
This test case writes data near the boundaries of the cache into an array of a size that you specify by using the After the test case reaches steady state, each memory access is a cache miss. The test case verifies the accuracy of write operations by reading back the data. The test case also verifies that values surrounding the changed values are not changed. This test case writes values to array indexes that surround multiples of eight. For each multiple of eight, the test case writes a value into the array at the following array indexes:
The test then reads and verifies the values. |
| Write Everything Read Everything (array = cache size)
213: No caching 243: Write-through cache mode 273: Write-back cache mode |
This test case searches for errors in consistency between data stored in the L1 data cache and data stored in main memory. By default, this test case runs for 10 minutes.
This test case sequentially writes data into an array that is the size of the L1 data cache as reported by the CeGetCacheInfo function. If the CeGetCacheInfo function reports that the size of the cache is zero, this test case uses a 4-MB array. After the test case reaches steady state, the write operations force a cache hit each time a memory value is accessed. The test case verifies the accuracy of write operations by reading back the data. The read operations also force cache misses. The test case assigns each array index a unique identifier. The test case references this unique identifier when it compares data read to data written. |
| Write Everything Read Everything (array = twice cache size)
214: No caching 244: Write-through cache mode 274: Write-back cache mode |
This test case searches for errors in consistency between data stored in the L1 data cache and data stored in main memory. By default, this test case runs for 10 minutes.
This test case sequentially writes data into an array that is twice the size of the L1 data cache as reported by the CeGetCacheInfo function. If the CeGetCacheInfo function reports that the size of the cache is zero, this test case uses a 4-MB array. After the test case reaches steady state, the write operations force a cache miss each time a memory value is accessed. The test case verifies the accuracy of write operations by reading back the data. The read operations also force cache misses. The test case assigns each unit of data a unique identifier. The test case references this unique identifier when it compares data read to data written. |
| Write Everything Read Everything (array = user defined)
215: No caching 245: Write-through cache mode 275: Write-back cache mode |
This test case searches for errors in consistency between data stored in the L1 data cache and data stored in main memory. By default, this test case runs for 10 minutes.
This test case sequentially writes data into an array that is of a size that you specify by using the After the test case reaches steady state, the write operations force a cache miss each time a memory value is accessed. The test case verifies the accuracy of write operations by reading back the data. The read operations also force cache misses. The test case assigns each array index a unique identifier. The test case references this unique identifier when it compares data read to data written. |
| Verify Near Powers of Two (array = cache size)
216: No caching 246: Write-through cache mode 276: Write-back cache mode |
This test case searches for errors in consistency between data stored in the L1 data cache and data stored in main memory. With a cache, errors generally fall on powers of two. This test case might expose errors not exposed by a test case that performs sequential write operations. By default, this test case runs for 10 minutes.
This test case writes data into values that are close to a power of two in an array that is the size of the L1 data cache as reported by the CeGetCacheInfo function. This test case exercises the cache rather than the underlying memory subsystem because in steady state, each memory access should be a cache hit. If the CeGetCacheInfo function reports that the size of the cache is zero, this test case uses a 4-MB array. The step size varies throughout the test case to expose errors that might occur only during a similar access sequence. The smallest step size is 16 bytes. For each power of two, the test case writes a value into the array at the following array indexes:
The test case then reads and verifies the values in the same order that they were written. |
| Verify Near Powers of Two (array = twice cache size)
217: No caching 247: Write-through cache mode 277: Write-back cache mode |
This test case searches for errors in consistency between data stored in the L1 data cache and data stored in main memory. With a cache, errors generally fall on powers of two. This test case might expose errors not exposed by a test case that performs sequential write operations. By default, this test case runs for 10 minutes.
This test case writes data into values that are close to a power of two in an array that is twice the size of the L1 data cache as reported by the CeGetCacheInfo function. If the CeGetCacheInfo function reports that the size of the cache is zero, this test case uses a 4-MB array. The step size varies throughout the test case to expose errors that might occur only during a similar access sequence. The smallest step size is 16 bytes. For each power of two, the test case writes a value into the array at the following array indexes:
The test case then reads and verifies the values in the same order that they were written. |
| Verify Near Powers of Two (array = user defined)
218: No caching 248: Write-through cache mode 278: Write-back cache mode |
This test case searches for errors in consistency between data stored in the L1 data cache and data stored in main memory. With a cache, errors generally fall on powers of two. This test case might expose errors not exposed by a test case that performs sequential write operations. By default, this test case runs for 10 minutes.
This test case writes data into values that are close to a power of two in an array of a size that you specify by using the The step size varies throughout the test case to expose errors that might occur only during a similar access sequence. The smallest step size is 16 bytes. For each power of two, the test case writes a value into the array at the following array indexes:
The test case then reads and verifies the values in the same order that they were written. |
| Write Everything Read Everything Mixed Up (array = twice cache size)
219: No caching 249: Write-through cache mode 279: Write-back cache mode |
This test case searches for errors in consistency between data stored in the L1 data cache and data stored in main memory. By default, this test case runs for 10 minutes.
This test case writes data in a semi-random way into an array that is twice the size of the L1 data cache as reported by the CeGetCacheInfo function. If the CeGetCacheInfo function reports that the size of the cache is zero, this test case uses a 4-MB array. This test case produces both cache misses and cache hits, thereby exercising the cache in a more random way than a sequential set of read and write operations would. The test case writes each value in the tested array once and verifies the value during a subsequent read pass. The sequence of write operations that this test case uses is semi-random. The sequence is not as random as a random number generator because the test case must access each value once and only once. The first 16 values in the sequence are 0, 3, 1, 2, 12, 15, 13, 14, 4, 7, 5, 6, 8, 11, 9, and 10. |
| Write Everything Read Everything Mixed Up (array = user defined)
220: No caching 250: Write-through cache mode 280: Write-back cache mode |
This test case searches for errors in consistency between data stored in the L1 data cache and data stored in main memory. By default, this test case runs for 10 minutes.
This test case writes data in a semi-random way into an array of a size that you specify by using the This test case produces both cache misses and cache hits, thereby exercising the cache is a more random way than a sequential set of read and write operations would. The test case writes each value in the tested array once and verifies the value during a subsequent read pass. The sequence of write operations that this test case uses is semi-random. The sequence is not as random as a random number generator because the test case must access each value once and only once. The first 16 values in the sequence are 0, 3, 1, 2, 12, 15, 13, 14, 4, 7, 5, 6, 8, 11, 9, and 10. |
See Also
OAL Cache Test | Command-Line Parameters for the OAL Cache Test | Best Practices for the OAL Cache Test
Send Feedback on this topic to the authors