Summary: Should you keep the default initialization parameters or apply a predefined configuration baseline? Instead of relying on experience or copying someone else's settings, this guide shows how to run a reproducible comparison test for GBase Database(GBase 8s), measure the results, and determine whether parameter tuning actually benefits your workload.
Initialization parameter discussions in GBase Database(GBase 8s) often turn into a debate: some engineers believe the defaults are sufficient, while others prefer tuning parameters before production deployment.
Neither approach is universally correct.
A better way to decide is to run a controlled comparison between the default onconfig and a predefined parameter baseline.
This article focuses on the testing methodology, not a universal performance conclusion. Results will vary depending on hardware, data volume, operating system configuration, and workload characteristics.
1. Design a Reproducible Configuration Test
The objective is to compare two configurations while keeping all other variables as consistent as possible.
Prepare two identical machines, or initialize the same machine twice using the same environment and test procedure.
Keep the following conditions consistent:
- Operating system: Same OS version and kernel parameters.
- Data: Same data volume, table structures, and indexes.
- SQL workload: Same SQL statements and execution sequence.
- Concurrency: Same connection ramp and workload duration.
- Network: Same client machines and network path.
The two test groups are defined as follows:
- Group A: Default
onconfigconfiguration. - Group B: A predefined initialization parameter baseline.
Here is an example baseline for GBase Database(GBase 8s):
VPCLASS cpu,num=16,noage MULTIPROCESSOR 1 NETTYPE soctcp,10,300,NET BUFFERPOOL size=16K,buffers=1000000 SHMVIRTSIZE 2048000 SHMADD 1024000 LOCKS 10000000 DEF_TABLE_LOCKMODE row These values are test inputs, not universal recommendations. Before applying them, verify that they are supported by the target GBase Database version and appropriate for the available hardware resources.
2. What Metrics Should You Measure?
A common mistake in database benchmarking is recording only QPS or TPS.
Initialization parameters can also affect connection handling, lock contention, buffer pool behavior, and memory consumption. A meaningful GBase Database performance test should cover at least four categories.
2.1 Connection Establishment
Observe whether connection establishment becomes slower as concurrency increases.
Record:
- Connection establishment latency
- Connection queueing
- Connection timeouts
- Failed connection attempts
This helps identify whether the instance can handle the target connection load.
2.2 Lock Waits
Record lock wait counts and the longest observed wait.
Application-side instrumentation can help identify how lock contention affects actual request latency.
Compare both groups under the same SQL workload and concurrency levels.
2.3 Buffer Pool Behavior
Use the onstat command family to observe buffer pool statistics.
Pay particular attention to:
- Buffer pool hit ratio
- Read and write activity
- Dirty page proportion
- Changes in buffer utilization under increasing concurrency
A larger buffer pool does not automatically guarantee better performance. Its effectiveness depends on the working set and available physical memory.
2.4 Memory Consumption and Paging
Monitor shared memory consumption and operating system memory usage.
The key question is whether the larger buffer pool and other memory allocations cause the operating system to start swapping.
Record:
- Physical memory utilization
- Shared memory allocation
- Swap usage
- Paging activity
A configuration that improves buffer pool statistics but triggers memory pressure may perform worse overall.
3. Execute the Comparison Test
Before running each group, confirm that the database instance is in the expected state.
# Confirm instance state before each group onstat - Use the same concurrency ramp for both groups:
| Test stage | Concurrent sessions |
|---|---|
| Stage 1 | 50 |
| Stage 2 | 100 |
| Stage 3 | 200 |
| Stage 4 | 400 |
Hold each stage long enough to collect stable measurements across all four observation categories.
After each group, record the effective configuration:
grep -E '^(VPCLASS|NETTYPE|BUFFERPOOL|SHMVIRTSIZE|SHMADD|LOCKS|DEF_TABLE_LOCKMODE)' \ $GBASEDBTDIR/etc/onconfig.gbaseserver Do not assume the configuration file alone proves which parameters were effective at runtime. Where applicable, verify the actual instance settings through the relevant GBase Database monitoring commands.
Repeat Each Test at Least Three Times
A single benchmark run can be distorted by:
- Buffer cache state
- Background database activity
- Concurrent operating system tasks
- Network jitter
- Uneven workload distribution
Run each test stage at least three times and compare the stable ranges rather than relying on one result.
If repeated results differ significantly, investigate environmental instability before drawing conclusions.
4. How to Interpret the Results
The objective is not to prove that the baseline is always faster. It is to understand how each configuration behaves under the target workload.
Scenario A: Group A and Group B perform similarly at low concurrency, but Group A queues connections earlier at high concurrency.
This suggests that configuration-related resource limits may be contributing to the bottleneck. Investigate connection handling, CPU availability, and network configuration before attributing the result to a single parameter.
Scenario B: Both groups remain stable at high concurrency.
The default configuration may already be sufficient for this particular workload.
There is little value in changing parameters simply to make the configuration look more sophisticated.
Scenario C: Group B performs worse than Group A.
Check memory sizing first.
The buffer pool, shared memory segments, and lock structures all consume system resources. Oversizing one or more of them can create memory pressure and paging.
This is an important principle in GBase Database parameter tuning: overall resource balance matters more than maximizing individual parameter values.
Also remember that connection queueing or lock waits do not automatically prove that instance configuration is the root cause. SQL execution plans, application behavior, CPU saturation, and storage I/O should remain part of the investigation.
5. Build a Test Report That Others Can Reproduce
A useful comparison report should contain enough information for another engineer to repeat the experiment.
At a minimum, include:
| Report section | Information to record |
|---|---|
| Machine specifications | CPU, memory, storage, OS, kernel |
| Data environment | Data volume, table structures, indexes |
| Configuration | Default and baseline parameter differences |
| Workload | SQL statements and execution sequence |
| Concurrency | 50, 100, 200, and 400 sessions |
| Measurements | Connection, lock, buffer pool, memory |
| Anomalies | Errors, timeouts, unstable runs |
| Conclusion | Observed differences and applicable workload |
Avoid statements such as "performance improved by 30%" without explaining the test environment.
A more useful conclusion is specific and verifiable:
"At 200 concurrent sessions, Group A began queuing connections, while Group B completed the same workload without connection queueing."
The conclusion should describe what happened under the tested conditions, not promise the same result in another environment.
6. Configuration Tuning Should Be Evidence-Based
Initialization parameters in GBase Database(GBase 8s) deserve serious attention, especially before production deployment.
But serious configuration management does not mean copying a parameter set from another project.
The right approach is to establish a reproducible baseline, compare it against the defaults, measure the actual workload, and document the results.
A configuration that works well for one hardware environment may be unsuitable for another.
One controlled comparison test that explains your own environment is more valuable than a remembered collection of supposedly optimal parameter values.
That is the foundation of evidence-based GBase Database initialization and performance tuning.
Keywords: GBase Database, GBase Database 8s, Database Initialization Parameters, Database Parameter Benchmark, onconfig Configuration, Database Performance Testing, Database Performance Tuning
