Overview

The Benchmark View provides a user interface for benchmarking the space.
The following options are provided:

• Specifying the JavaSpaces API operation to perform (write, read, take, notify), or the Map API operation to perform (put, get, remove).
• Specifying the number of iterations to perform.
• Specifying the sampling rate.
• Specifying Entry size.
• Specifying batch size.
• Specifying the number of concurrent threads.
• Specifying the transaction type.
• Specify parallel operations. For example, running write and read operations in separate threads concurrently.
• Specify UID-based operations.
• Specify distributed cache mode.
• Export results to a CSV file.
• Display results in graph and tabular form.

Settings Tab

The Settings panel allows you to configure the benchmark parameters. It contains the following options:

• Threads – the number of concurrent threads that run the test. This allows you to run multiple threads that call the selected operation at the same time.

  If you define that 1000 Entries be written to the space, and have 5 threads defined as part of the threads box, you will end up with 5000 Entries inside the space.

• Iterations – the number of iterations the benchmark will call for the selected operation.

  You can allow a read cycle to be conducted several times using the Repeat Read option.

• Entry size – the size of the Entry payload in bytes that will be written to the space. This option is relevant only for the write and put operations.
• Sampling Rate – the benchmark will provide the average TP reading on the graph or table tabs based on the sampling rate. For example, if you chose to write 5000 Entries to the space and the sampling rate is 1000 - the results graph and table will have 5 sampling points, which reflect the average TP of the Write operation for the last sampling period (the last 1000 Write operations). When using the Repeat Read option, you can select a sampling rate that is greater than the number of iterations.
• Batches – this option allows you to call GigaSpaces batch operations (writeMultiple, takeMultiple, readMultiple). The number specified in this box is the number of batches that will be performed to complete the number of iterations specified. Specifying 0 as the batch size will call the regular APIs.
• Use UID check box – when this option is turned on (check box is checked), the write option constructs the Entry UID and uses it when calling the read operation. This option uses an Entry without any indexes.
• FIFO check box – allows you to specify that the objects you write to the space are written in FIFO mode.
• Save results to file – to save the benchmark sample readings into a file, check this option and specify a file. This will generate a file with the results in tab-separated values.
• Transaction
  • None – operations will be called without using transactions.
  • Local – the GigaSpaces Local Transaction Manager will be used to create the transaction object with the operations.
  • Distributed - the Jini Distributed Transaction Manager will be used to create the transaction object with the operations.
• Clean Space - if checked, the target space will be cleaned prior to the start of the benchmark.
• Operations – you can call the JavaSpaces API or the Map API:
  • JavaSpaces API:
    • Write – writes Entries to the space.
    • Read – reads Entries from the space.
    • Take – takes Entries from the space.
    • Write and Read – writes and reads Entries. There will be a number of iterations for Write operations and a number of iterations for Read operations.
    • Write and Take – writes (Ni / 2) and Takes (Ni / 2) messages, where Ni is the number of iterations.
      JavaSpaces operations use an Entry with 2 attributes:
    • m_counter – java.lang.Long. This stores a running number. This is an indexed attribute. Take and read operations use this attribute for template matching.
    • m_content – java.lang.Byte[]. This stores the payload data.
  • Map API:
    • Put – puts Entries in the space.
    • Get – gets Entries from the space.
    • Remove – removes Entries from the space.
    • Put and Get – puts Entries into the space, and gets Entries from the space.
    • Put and Remove – puts Entries into the space, and removes Entries from the space.
      The Map operations put an object with 2 attributes (value object) and a string key into the space.
• Parallel operations – this option is relevant only for the write and read, write and take, put and get, and put and remove operations. When selecting this option, the operations will be conducted simultaneously – i.e., a thread will be spawned for the write operation, another one for the read operation, and these will be executed at the same time, allowing the read thread to read an Entry that has been written by the write thread.
• Use Local Cache – distributed cache is relevant when using read or get operations. This option starts a local cache at the space browser VM. When a read or get operation is called, the Entry is first searched for at the local cache. If the Entry is not found at the local cache, it is searched for at the master space and sent back to the browser. Any subsequent read for the Entry will be conducted from the local cache.
  You can use the following local cache implementations:
  • Standard – available for the JavaSpaces API and the Map API. Includes sophisticated eviction options.
  • Light – Available for the JavaSpaces API and the Map API.

    Renamed in GigaSpaces 5.2 The Master-Local Cache check box has been renamed to Use Local Cache in GigaSpaces 5.2 and onwards.

• Repeat Read/Get Operation – this option is relevant for the read or get operations. Specify the number of times the repeat cycle will be repeated. This option allows you to benchmark the local cache.
  
• Object type – allows you to specify the type of object that is written to the space. You can select Entry, POJO, Externalizable, Serializable, FIFO, or UID from the drop-down menu.

New in GigaSpaces 5.2 The Object type field is a new option in GigaSpaces version 5.2 and onwards.

Starting or Stopping the Benchmark

• Start Button – after completing the benchmark settings, click the Start button to invoke the selected operation(s) based on the configuration defined at the Settings tab.
• Stop Button – to stop the currently running benchmark, click the Stop button.

Progress Bar

The Progress Bar displays the current benchmark status.

Table Tab

The Table Tab allows you to view the benchmark results in tabular format. The table provides the throughput for write, read, or take operations, and the client process memory available during the test period.

To clear the Table Tab, click the Clear button.

Graph Tab

The Graph Tab allows you to view the benchmark results using graphs. The graphs provided show the throughput for Write/Read/Take operations and the client process memory available during the test period.

To clear the Graph Tab, click the Clear button.

Summary Tab

The Summary Tab includes the benchmark results summary.
When running multiple benchmarks, the last benchmark summary is added to the previously displayed summaries.
The Summary Tab includes the client System Environment - OS, JDK, Memory, the total time of the benchmark, the average throughput, and the number of bytes written/read from the space.

To clear the Summary Tab, click the Clear button.

Benchmark Example

The benchmark example provides a good tool for running performance benchmarks on the cache in various scenarios. This program performs a loop of write/put and read/get, or take/remove operations from a space, according to a different set of parameters. The result is the average time it took to perform the operations. You can define a sampling rate to allow you to track the intermediate performance while the benchmark example is running. You may also dump the results into a file to be converted into graphs and analyzed using a spreadsheet and analysis tools.

For more details, refer to the Benchmark Example section.