Merge branch 'main' into bojan-get-page-tests

test_runner/performance/test_bulk_tenant_create.py

@@ -13,15 +13,15 @@ from fixtures.zenith_fixtures import ZenithEnvBuilder
 
 
 @pytest.mark.parametrize('tenants_count', [1, 5, 10])
-@pytest.mark.parametrize('use_wal_acceptors', ['with_wa', 'without_wa'])
+@pytest.mark.parametrize('use_safekeepers', ['with_wa', 'without_wa'])
 def test_bulk_tenant_create(
     zenith_env_builder: ZenithEnvBuilder,
-    use_wal_acceptors: str,
+    use_safekeepers: str,
     tenants_count: int,
     zenbenchmark,
 ):
     """Measure tenant creation time (with and without wal acceptors)"""
-    if use_wal_acceptors == 'with_wa':
+    if use_safekeepers == 'with_wa':
         zenith_env_builder.num_safekeepers = 3
     env = zenith_env_builder.init_start()
 
@@ -32,14 +32,14 @@ def test_bulk_tenant_create(
 
         tenant = env.zenith_cli.create_tenant()
         env.zenith_cli.create_timeline(
-            f'test_bulk_tenant_create_{tenants_count}_{i}_{use_wal_acceptors}', tenant_id=tenant)
+            f'test_bulk_tenant_create_{tenants_count}_{i}_{use_safekeepers}', tenant_id=tenant)
 
         # FIXME: We used to start new safekeepers here. Did that make sense? Should we do it now?
-        #if use_wal_acceptors == 'with_wa':
+        #if use_safekeepers == 'with_sa':
         #    wa_factory.start_n_new(3)
 
         pg_tenant = env.postgres.create_start(
-            f'test_bulk_tenant_create_{tenants_count}_{i}_{use_wal_acceptors}', tenant_id=tenant)
+            f'test_bulk_tenant_create_{tenants_count}_{i}_{use_safekeepers}', tenant_id=tenant)
 
         end = timeit.default_timer()
         time_slices.append(end - start)

test_runner/performance/test_perf_pgbench.py

@@ -1,5 +1,5 @@
 from contextlib import closing
-from fixtures.zenith_fixtures import PgBin, VanillaPostgres, ZenithEnv
+from fixtures.zenith_fixtures import PgBin, VanillaPostgres, ZenithEnv, profiling_supported
 from fixtures.compare_fixtures import PgCompare, VanillaCompare, ZenithCompare
 
 from fixtures.benchmark_fixture import PgBenchRunResult, MetricReport, ZenithBenchmarker
@@ -106,6 +106,28 @@ def test_pgbench(zenith_with_baseline: PgCompare, scale: int, duration: int):
     run_test_pgbench(zenith_with_baseline, scale, duration)
 
 
+# Run the pgbench tests, and generate a flamegraph from it
+# This requires that the pageserver was built with the 'profiling' feature.
+#
+# TODO: If the profiling is cheap enough, there's no need to run the same test
+# twice, with and without profiling. But for now, run it separately, so that we
+# can see how much overhead the profiling adds.
+@pytest.mark.parametrize("scale", get_scales_matrix())
+@pytest.mark.parametrize("duration", get_durations_matrix())
+def test_pgbench_flamegraph(zenbenchmark, pg_bin, zenith_env_builder, scale: int, duration: int):
+    zenith_env_builder.num_safekeepers = 1
+    zenith_env_builder.pageserver_config_override = '''
+profiling="page_requests"
+'''
+    if not profiling_supported():
+        pytest.skip("pageserver was built without 'profiling' feature")
+
+    env = zenith_env_builder.init_start()
+    env.zenith_cli.create_branch("empty", "main")
+
+    run_test_pgbench(ZenithCompare(zenbenchmark, env, pg_bin, "pgbench"), scale, duration)
+
+
 # Run the pgbench tests against an existing Postgres cluster
 @pytest.mark.parametrize("scale", get_scales_matrix())
 @pytest.mark.parametrize("duration", get_durations_matrix())

test_runner/performance/test_startup.py

@@ -0,0 +1,48 @@
+from contextlib import closing
+
+from fixtures.zenith_fixtures import ZenithEnvBuilder
+from fixtures.benchmark_fixture import ZenithBenchmarker
+
+
+def test_startup(zenith_env_builder: ZenithEnvBuilder, zenbenchmark: ZenithBenchmarker):
+    zenith_env_builder.num_safekeepers = 3
+    env = zenith_env_builder.init_start()
+
+    # Start
+    env.zenith_cli.create_branch('test_startup')
+    with zenbenchmark.record_duration("startup_time"):
+        pg = env.postgres.create_start('test_startup')
+        pg.safe_psql("select 1;")
+
+    # Restart
+    pg.stop_and_destroy()
+    with zenbenchmark.record_duration("restart_time"):
+        pg.create_start('test_startup')
+        pg.safe_psql("select 1;")
+
+    # Fill up
+    num_rows = 1000000  # 30 MB
+    num_tables = 100
+    with closing(pg.connect()) as conn:
+        with conn.cursor() as cur:
+            for i in range(num_tables):
+                cur.execute(f'create table t_{i} (i integer);')
+                cur.execute(f'insert into t_{i} values (generate_series(1,{num_rows}));')
+
+    # Read
+    with zenbenchmark.record_duration("read_time"):
+        pg.safe_psql("select * from t_0;")
+
+    # Read again
+    with zenbenchmark.record_duration("second_read_time"):
+        pg.safe_psql("select * from t_0;")
+
+    # Restart
+    pg.stop_and_destroy()
+    with zenbenchmark.record_duration("restart_with_data"):
+        pg.create_start('test_startup')
+        pg.safe_psql("select 1;")
+
+    # Read
+    with zenbenchmark.record_duration("read_after_restart"):
+        pg.safe_psql("select * from t_0;")