From 0c524d379eb46f4937f8c401f4e0a1864db555ea Mon Sep 17 00:00:00 2001 From: Ben Jeffery Date: Thu, 16 Sep 2021 15:01:03 +0100 Subject: [PATCH] Change ragged column expansion behaviour to doubling --- c/CHANGELOG.rst | 11 ++- c/tests/test_tables.c | 168 ++++++++++++++++++++++-------------------- c/tskit/tables.c | 139 +++++++++++++++++----------------- 3 files changed, 165 insertions(+), 153 deletions(-) diff --git a/c/CHANGELOG.rst b/c/CHANGELOG.rst index a4eb87e473..fb06b5a9d6 100644 --- a/c/CHANGELOG.rst +++ b/c/CHANGELOG.rst @@ -9,12 +9,19 @@ **Features** -- The default behaviour for table size growth is now to double the current size of the table. - To keep the current behaviour, use (e.g.) +- The default behaviour for table size growth is now to double the current size of the table, + up to a threshold. To keep the previous behaviour, use (e.g.) ``tsk_edge_table_set_max_rows_increment(tables->edges, 1024)``, which results in adding space for 1024 additional rows each time we run out of space in the edge table. (:user:`benjeffery`, :issue:`5`, :pr:`1683`) +- The default behaviour for ragged column growth is now to double the current size of the column, + up to a threshold. To keep the previous behaviour, use (e.g.) + ``tsk_node_table_set_max_metadata_length_increment(tables->nodes, 1024)``, which results in adding + space for 1024 additional entries each time we run out of space in the ragged column. + (:user:`benjeffery`, :issue:`1703`, :pr:`1709`) + + **Fixes** ---------------------- diff --git a/c/tests/test_tables.c b/c/tests/test_tables.c index 4632100921..e23083613a 100644 --- a/c/tests/test_tables.c +++ b/c/tests/test_tables.c @@ -4298,100 +4298,31 @@ test_table_size_increments(void) { int ret; tsk_table_collection_t tables; - tsk_size_t default_size = 1024; tsk_size_t new_size; ret = tsk_table_collection_init(&tables, 0); CU_ASSERT_EQUAL_FATAL(ret, 0); CU_ASSERT_EQUAL_FATAL(tables.individuals.max_rows_increment, 0); - CU_ASSERT_EQUAL_FATAL( - tables.individuals.max_metadata_length_increment, default_size); - CU_ASSERT_EQUAL_FATAL( - tables.individuals.max_location_length_increment, default_size); + CU_ASSERT_EQUAL_FATAL(tables.individuals.max_metadata_length_increment, 0); + CU_ASSERT_EQUAL_FATAL(tables.individuals.max_location_length_increment, 0); CU_ASSERT_EQUAL_FATAL(tables.nodes.max_rows_increment, 0); - CU_ASSERT_EQUAL_FATAL(tables.nodes.max_metadata_length_increment, default_size); + CU_ASSERT_EQUAL_FATAL(tables.nodes.max_metadata_length_increment, 0); CU_ASSERT_EQUAL_FATAL(tables.edges.max_rows_increment, 0); - CU_ASSERT_EQUAL_FATAL(tables.edges.max_metadata_length_increment, default_size); + CU_ASSERT_EQUAL_FATAL(tables.edges.max_metadata_length_increment, 0); CU_ASSERT_EQUAL_FATAL(tables.sites.max_rows_increment, 0); - CU_ASSERT_EQUAL_FATAL(tables.sites.max_metadata_length_increment, default_size); - CU_ASSERT_EQUAL_FATAL( - tables.sites.max_ancestral_state_length_increment, default_size); + CU_ASSERT_EQUAL_FATAL(tables.sites.max_metadata_length_increment, 0); + CU_ASSERT_EQUAL_FATAL(tables.sites.max_ancestral_state_length_increment, 0); CU_ASSERT_EQUAL_FATAL(tables.mutations.max_rows_increment, 0); - CU_ASSERT_EQUAL_FATAL(tables.mutations.max_metadata_length_increment, default_size); - CU_ASSERT_EQUAL_FATAL( - tables.mutations.max_derived_state_length_increment, default_size); + CU_ASSERT_EQUAL_FATAL(tables.mutations.max_metadata_length_increment, 0); + CU_ASSERT_EQUAL_FATAL(tables.mutations.max_derived_state_length_increment, 0); CU_ASSERT_EQUAL_FATAL(tables.migrations.max_rows_increment, 0); - CU_ASSERT_EQUAL_FATAL(tables.migrations.max_metadata_length_increment, default_size); + CU_ASSERT_EQUAL_FATAL(tables.migrations.max_metadata_length_increment, 0); CU_ASSERT_EQUAL_FATAL(tables.populations.max_rows_increment, 0); - CU_ASSERT_EQUAL_FATAL( - tables.populations.max_metadata_length_increment, default_size); + CU_ASSERT_EQUAL_FATAL(tables.populations.max_metadata_length_increment, 0); CU_ASSERT_EQUAL_FATAL(tables.provenances.max_rows_increment, 0); - CU_ASSERT_EQUAL_FATAL( - tables.provenances.max_timestamp_length_increment, default_size); - CU_ASSERT_EQUAL_FATAL(tables.provenances.max_record_length_increment, default_size); - - /* Setting to zero sets to the default size */ - new_size = 0; - ret = tsk_individual_table_set_max_metadata_length_increment( - &tables.individuals, new_size); - CU_ASSERT_EQUAL_FATAL(ret, 0); - CU_ASSERT_EQUAL_FATAL( - tables.individuals.max_metadata_length_increment, default_size); - ret = tsk_individual_table_set_max_location_length_increment( - &tables.individuals, new_size); - CU_ASSERT_EQUAL_FATAL(ret, 0); - CU_ASSERT_EQUAL_FATAL( - tables.individuals.max_location_length_increment, default_size); - ret = tsk_individual_table_set_max_parents_length_increment( - &tables.individuals, new_size); - CU_ASSERT_EQUAL_FATAL(ret, 0); - CU_ASSERT_EQUAL_FATAL(tables.individuals.max_parents_length_increment, default_size); - - ret = tsk_node_table_set_max_metadata_length_increment(&tables.nodes, new_size); - CU_ASSERT_EQUAL_FATAL(ret, 0); - CU_ASSERT_EQUAL_FATAL(tables.nodes.max_metadata_length_increment, default_size); - - ret = tsk_edge_table_set_max_metadata_length_increment(&tables.edges, new_size); - CU_ASSERT_EQUAL_FATAL(ret, 0); - CU_ASSERT_EQUAL_FATAL(tables.edges.max_metadata_length_increment, default_size); - - ret = tsk_site_table_set_max_metadata_length_increment(&tables.sites, new_size); - CU_ASSERT_EQUAL_FATAL(ret, 0); - CU_ASSERT_EQUAL_FATAL(tables.sites.max_metadata_length_increment, default_size); - ret = tsk_site_table_set_max_ancestral_state_length_increment( - &tables.sites, new_size); - CU_ASSERT_EQUAL_FATAL(ret, 0); - CU_ASSERT_EQUAL_FATAL( - tables.sites.max_ancestral_state_length_increment, default_size); - - ret = tsk_mutation_table_set_max_metadata_length_increment( - &tables.mutations, new_size); - CU_ASSERT_EQUAL_FATAL(ret, 0); - CU_ASSERT_EQUAL_FATAL(tables.mutations.max_metadata_length_increment, default_size); - ret = tsk_mutation_table_set_max_derived_state_length_increment( - &tables.mutations, new_size); - CU_ASSERT_EQUAL_FATAL(ret, 0); - CU_ASSERT_EQUAL_FATAL( - tables.mutations.max_derived_state_length_increment, default_size); - - ret = tsk_migration_table_set_max_metadata_length_increment( - &tables.migrations, new_size); - CU_ASSERT_EQUAL_FATAL(ret, 0); - CU_ASSERT_EQUAL_FATAL(tables.migrations.max_metadata_length_increment, default_size); - - ret = tsk_population_table_set_max_metadata_length_increment( - &tables.populations, new_size); - CU_ASSERT_EQUAL_FATAL( - tables.populations.max_metadata_length_increment, default_size); - - ret = tsk_provenance_table_set_max_timestamp_length_increment( - &tables.provenances, new_size); - CU_ASSERT_EQUAL_FATAL( - tables.provenances.max_timestamp_length_increment, default_size); - ret = tsk_provenance_table_set_max_record_length_increment( - &tables.provenances, new_size); - CU_ASSERT_EQUAL_FATAL(tables.provenances.max_record_length_increment, default_size); + CU_ASSERT_EQUAL_FATAL(tables.provenances.max_timestamp_length_increment, 0); + CU_ASSERT_EQUAL_FATAL(tables.provenances.max_record_length_increment, 0); /* Setting to non-zero sets to that size */ new_size = 1; @@ -4989,6 +4920,80 @@ test_table_expansion(void) tsk_table_collection_free(&tables2); } +static void +test_ragged_expansion(void) +{ + int ret; + tsk_id_t ret_id; + tsk_table_collection_t tables; + char *data = tsk_malloc(104857600 * sizeof(char)); + + /* Test with node table metadata */ + ret = tsk_table_collection_init(&tables, 0); + CU_ASSERT_EQUAL_FATAL(ret, 0); + + CU_ASSERT_EQUAL_FATAL(tables.nodes.max_metadata_length, 1); + + /*Extending by a small amount results in 65536 bytes in the first case*/ + ret_id = tsk_node_table_add_row(&tables.nodes, 0, 0, TSK_NULL, TSK_NULL, data, 2); + CU_ASSERT_EQUAL_FATAL(ret_id, 0); + CU_ASSERT_EQUAL_FATAL(tables.nodes.max_metadata_length, 65536); + + /*Extending by an amount that fits doesn't grow the column*/ + ret_id + = tsk_node_table_add_row(&tables.nodes, 0, 0, TSK_NULL, TSK_NULL, data, 65534); + CU_ASSERT_EQUAL_FATAL(ret_id, 1); + CU_ASSERT_EQUAL_FATAL(tables.nodes.max_metadata_length, 65536); + + /*Extending by an amount that doesn't fit doubles the column*/ + ret_id = tsk_node_table_add_row(&tables.nodes, 0, 0, TSK_NULL, TSK_NULL, data, 1); + CU_ASSERT_EQUAL_FATAL(ret_id, 2); + CU_ASSERT_EQUAL_FATAL(tables.nodes.max_metadata_length, 65536 * 2); + + /*Extending by an amount greater than the next double extends to that amount*/ + ret_id = tsk_node_table_add_row(&tables.nodes, 0, 0, TSK_NULL, TSK_NULL, data, + 1 + (65536 * 2 * 2 - 2 - 65534 - 1)); + CU_ASSERT_EQUAL_FATAL(ret_id, 3); + CU_ASSERT_EQUAL_FATAL(tables.nodes.max_metadata_length, 2 + 65534 + 1 + 196608); + + /*After extending beyond 100MB subsequent extension doesn't double but adds 100MB*/ + ret_id = tsk_node_table_add_row( + &tables.nodes, 0, 0, TSK_NULL, TSK_NULL, data, 104857600); + CU_ASSERT_EQUAL_FATAL(ret_id, 4); + CU_ASSERT_EQUAL_FATAL(tables.nodes.max_metadata_length, 105119745); + ret_id = tsk_node_table_add_row(&tables.nodes, 0, 0, TSK_NULL, TSK_NULL, data, 1); + CU_ASSERT_EQUAL_FATAL(ret_id, 5); + CU_ASSERT_EQUAL_FATAL(tables.nodes.max_metadata_length, 105119745 + 104857600); + + /*Extending by more bytes than possible results in overflow*/ + ret_id = tsk_node_table_add_row( + &tables.nodes, 0, 0, TSK_NULL, TSK_NULL, data, TSK_MAX_SIZE); + CU_ASSERT_EQUAL_FATAL(ret_id, TSK_ERR_COLUMN_OVERFLOW); + CU_ASSERT_EQUAL_FATAL(tables.nodes.max_metadata_length, 105119745 + 104857600); + + tsk_node_table_free(&tables.nodes); + ret = tsk_node_table_init(&tables.nodes, 0); + CU_ASSERT_EQUAL_FATAL(ret, 0); + + /*Setting a custom extension uses that*/ + ret = tsk_node_table_set_max_metadata_length_increment(&tables.nodes, 42); + CU_ASSERT_EQUAL_FATAL(ret, 0); + + ret_id = tsk_node_table_add_row(&tables.nodes, 0, 0, TSK_NULL, TSK_NULL, data, 3); + CU_ASSERT_EQUAL_FATAL(ret_id, 0); + CU_ASSERT_EQUAL_FATAL(tables.nodes.max_metadata_length, 43); + + /*Setting a custom extension that overflows errors*/ + ret = tsk_node_table_set_max_metadata_length_increment(&tables.nodes, TSK_MAX_SIZE); + CU_ASSERT_EQUAL_FATAL(ret, 0); + ret_id = tsk_node_table_add_row(&tables.nodes, 0, 0, TSK_NULL, TSK_NULL, data, 41); + CU_ASSERT_EQUAL_FATAL(ret_id, TSK_ERR_COLUMN_OVERFLOW); + CU_ASSERT_EQUAL_FATAL(tables.nodes.max_metadata_length, 43); + + tsk_table_collection_free(&tables); + tsk_safe_free(data); +} + static void test_link_ancestors_input_errors(void) { @@ -8403,6 +8408,7 @@ main(int argc, char **argv) { "test_provenance_table_update_row", test_provenance_table_update_row }, { "test_table_size_increments", test_table_size_increments }, { "test_table_expansion", test_table_expansion }, + { "test_ragged_expansion", test_ragged_expansion }, { "test_table_collection_equals_options", test_table_collection_equals_options }, { "test_table_collection_simplify_errors", test_table_collection_simplify_errors }, diff --git a/c/tskit/tables.c b/c/tskit/tables.c index 9a0c0baa3b..f67c59b7c0 100644 --- a/c/tskit/tables.c +++ b/c/tskit/tables.c @@ -35,7 +35,6 @@ #define _TSK_WORKAROUND_FALSE_CLANG_WARNING #include -#define DEFAULT_SIZE_INCREMENT 1024 #define TABLE_SEP "-----------------------------------------\n" #define TSK_COL_OPTIONAL (1 << 0) @@ -495,22 +494,68 @@ calculate_max_rows(tsk_size_t num_rows, tsk_size_t max_rows, if (new_max_rows - max_rows > 2097152) { new_max_rows = max_rows + 2097152; } - new_max_rows = TSK_MAX(new_max_rows, num_rows + additional_rows); } else { /* Use user increment value */ if (check_table_overflow(max_rows, max_rows_increment)) { ret = TSK_ERR_TABLE_OVERFLOW; goto out; } - new_max_rows - = TSK_MAX(max_rows + max_rows_increment, num_rows + additional_rows); + new_max_rows = max_rows + max_rows_increment; } + new_max_rows = TSK_MAX(new_max_rows, num_rows + additional_rows); } *ret_new_max_rows = new_max_rows; out: return ret; } +static int +calculate_max_length(tsk_size_t current_length, tsk_size_t max_length, + tsk_size_t max_length_increment, tsk_size_t additional_length, + tsk_size_t *ret_new_max_length) +{ + tsk_size_t new_max_length; + int ret = 0; + + if (check_offset_overflow(current_length, additional_length)) { + ret = TSK_ERR_COLUMN_OVERFLOW; + goto out; + } + + if (current_length + additional_length <= max_length) { + new_max_length = max_length; + } else { + if (max_length_increment == 0) { + /* Doubling by default */ + new_max_length = TSK_MIN(max_length * 2, TSK_MAX_SIZE); + /* Add some constraints to prevent very small allocations */ + if (new_max_length < 65536) { + new_max_length = 65536; + } + /* Prevent allocating more than 100MB additional unless needed*/ + if (new_max_length - max_length > 104857600) { + new_max_length = max_length + 104857600; + } + new_max_length = TSK_MAX(new_max_length, current_length + additional_length); + } else { + /* Use user increment value */ + if (check_offset_overflow(max_length, max_length_increment)) { + /* Here we could allocate to the maximum size. + * Instead we are erroring out as this is much easier to test. + * The cost is that (at most) the last "max_length_increment"-1 + * bytes of the possible array space can't be used. */ + ret = TSK_ERR_COLUMN_OVERFLOW; + goto out; + } + new_max_length = max_length + max_length_increment; + } + new_max_length = TSK_MAX(new_max_length, current_length + additional_length); + } + *ret_new_max_length = new_max_length; +out: + return ret; +} + static int expand_column(void **column, tsk_size_t new_max_rows, size_t element_size) { @@ -533,27 +578,20 @@ expand_ragged_column(tsk_size_t current_length, tsk_size_t additional_length, size_t element_size) { int ret = 0; - tsk_size_t increment = TSK_MAX(additional_length, max_length_increment); + tsk_size_t new_max_length; - if (check_offset_overflow(current_length, additional_length)) { - ret = TSK_ERR_COLUMN_OVERFLOW; + ret = calculate_max_length(current_length, *max_length, max_length_increment, + additional_length, &new_max_length); + if (ret != 0) { goto out; } - if ((current_length + additional_length) > *max_length) { - if (check_offset_overflow(*max_length, increment)) { - /* Here we could allocate to the maximum size. - * Instead we are erroring out as this is much easier to test. - * The cost is that (at most) the last "max_length_increment"-1 - * bytes of the possible array space can't be used. */ - ret = TSK_ERR_COLUMN_OVERFLOW; - goto out; - } - ret = expand_column(column, *max_length + increment, element_size); + if (new_max_length > *max_length) { + ret = expand_column(column, new_max_length, element_size); if (ret != 0) { goto out; } - *max_length += increment; + *max_length = new_max_length; } out: return ret; @@ -670,9 +708,6 @@ int tsk_individual_table_set_max_metadata_length_increment( tsk_individual_table_t *self, tsk_size_t max_metadata_length_increment) { - if (max_metadata_length_increment == 0) { - max_metadata_length_increment = DEFAULT_SIZE_INCREMENT; - } self->max_metadata_length_increment = (tsk_size_t) max_metadata_length_increment; return 0; } @@ -681,9 +716,6 @@ int tsk_individual_table_set_max_location_length_increment( tsk_individual_table_t *self, tsk_size_t max_location_length_increment) { - if (max_location_length_increment == 0) { - max_location_length_increment = DEFAULT_SIZE_INCREMENT; - } self->max_location_length_increment = (tsk_size_t) max_location_length_increment; return 0; } @@ -692,9 +724,6 @@ int tsk_individual_table_set_max_parents_length_increment( tsk_individual_table_t *self, tsk_size_t max_parents_length_increment) { - if (max_parents_length_increment == 0) { - max_parents_length_increment = DEFAULT_SIZE_INCREMENT; - } self->max_parents_length_increment = (tsk_size_t) max_parents_length_increment; return 0; } @@ -731,9 +760,9 @@ tsk_individual_table_init(tsk_individual_table_t *self, tsk_flags_t TSK_UNUSED(o } self->metadata_offset[0] = 0; self->max_rows_increment = 0; - self->max_location_length_increment = DEFAULT_SIZE_INCREMENT; - self->max_parents_length_increment = DEFAULT_SIZE_INCREMENT; - self->max_metadata_length_increment = DEFAULT_SIZE_INCREMENT; + self->max_location_length_increment = 0; + self->max_parents_length_increment = 0; + self->max_metadata_length_increment = 0; tsk_individual_table_set_metadata_schema(self, NULL, 0); out: return ret; @@ -1428,9 +1457,6 @@ int tsk_node_table_set_max_metadata_length_increment( tsk_node_table_t *self, tsk_size_t max_metadata_length_increment) { - if (max_metadata_length_increment == 0) { - max_metadata_length_increment = DEFAULT_SIZE_INCREMENT; - } self->max_metadata_length_increment = max_metadata_length_increment; return 0; } @@ -1455,7 +1481,7 @@ tsk_node_table_init(tsk_node_table_t *self, tsk_flags_t TSK_UNUSED(options)) } self->metadata_offset[0] = 0; self->max_rows_increment = 0; - self->max_metadata_length_increment = DEFAULT_SIZE_INCREMENT; + self->max_metadata_length_increment = 0; tsk_node_table_set_metadata_schema(self, NULL, 0); out: return ret; @@ -2027,9 +2053,6 @@ int tsk_edge_table_set_max_metadata_length_increment( tsk_edge_table_t *self, tsk_size_t max_metadata_length_increment) { - if (max_metadata_length_increment == 0) { - max_metadata_length_increment = DEFAULT_SIZE_INCREMENT; - } self->max_metadata_length_increment = max_metadata_length_increment; return 0; } @@ -2058,7 +2081,7 @@ tsk_edge_table_init(tsk_edge_table_t *self, tsk_flags_t options) self->metadata_offset[0] = 0; } self->max_rows_increment = 0; - self->max_metadata_length_increment = DEFAULT_SIZE_INCREMENT; + self->max_metadata_length_increment = 0; tsk_edge_table_set_metadata_schema(self, NULL, 0); out: return ret; @@ -2702,9 +2725,6 @@ int tsk_site_table_set_max_metadata_length_increment( tsk_site_table_t *self, tsk_size_t max_metadata_length_increment) { - if (max_metadata_length_increment == 0) { - max_metadata_length_increment = DEFAULT_SIZE_INCREMENT; - } self->max_metadata_length_increment = max_metadata_length_increment; return 0; } @@ -2713,9 +2733,6 @@ int tsk_site_table_set_max_ancestral_state_length_increment( tsk_site_table_t *self, tsk_size_t max_ancestral_state_length_increment) { - if (max_ancestral_state_length_increment == 0) { - max_ancestral_state_length_increment = DEFAULT_SIZE_INCREMENT; - } self->max_ancestral_state_length_increment = max_ancestral_state_length_increment; return 0; } @@ -2747,8 +2764,8 @@ tsk_site_table_init(tsk_site_table_t *self, tsk_flags_t TSK_UNUSED(options)) self->ancestral_state_offset[0] = 0; self->metadata_offset[0] = 0; self->max_rows_increment = 0; - self->max_ancestral_state_length_increment = DEFAULT_SIZE_INCREMENT; - self->max_metadata_length_increment = DEFAULT_SIZE_INCREMENT; + self->max_ancestral_state_length_increment = 0; + self->max_metadata_length_increment = 0; tsk_site_table_set_metadata_schema(self, NULL, 0); out: return ret; @@ -3342,9 +3359,6 @@ int tsk_mutation_table_set_max_metadata_length_increment( tsk_mutation_table_t *self, tsk_size_t max_metadata_length_increment) { - if (max_metadata_length_increment == 0) { - max_metadata_length_increment = DEFAULT_SIZE_INCREMENT; - } self->max_metadata_length_increment = max_metadata_length_increment; return 0; } @@ -3353,9 +3367,6 @@ int tsk_mutation_table_set_max_derived_state_length_increment( tsk_mutation_table_t *self, tsk_size_t max_derived_state_length_increment) { - if (max_derived_state_length_increment == 0) { - max_derived_state_length_increment = DEFAULT_SIZE_INCREMENT; - } self->max_derived_state_length_increment = max_derived_state_length_increment; return 0; } @@ -3387,8 +3398,8 @@ tsk_mutation_table_init(tsk_mutation_table_t *self, tsk_flags_t TSK_UNUSED(optio self->derived_state_offset[0] = 0; self->metadata_offset[0] = 0; self->max_rows_increment = 0; - self->max_derived_state_length_increment = DEFAULT_SIZE_INCREMENT; - self->max_metadata_length_increment = DEFAULT_SIZE_INCREMENT; + self->max_derived_state_length_increment = 0; + self->max_metadata_length_increment = 0; tsk_mutation_table_set_metadata_schema(self, NULL, 0); out: return ret; @@ -4021,9 +4032,6 @@ int tsk_migration_table_set_max_metadata_length_increment( tsk_migration_table_t *self, tsk_size_t max_metadata_length_increment) { - if (max_metadata_length_increment == 0) { - max_metadata_length_increment = DEFAULT_SIZE_INCREMENT; - } self->max_metadata_length_increment = max_metadata_length_increment; return 0; } @@ -4049,7 +4057,7 @@ tsk_migration_table_init(tsk_migration_table_t *self, tsk_flags_t TSK_UNUSED(opt } self->metadata_offset[0] = 0; self->max_rows_increment = 0; - self->max_metadata_length_increment = DEFAULT_SIZE_INCREMENT; + self->max_metadata_length_increment = 0; tsk_migration_table_set_metadata_schema(self, NULL, 0); out: return ret; @@ -4590,9 +4598,6 @@ int tsk_population_table_set_max_metadata_length_increment( tsk_population_table_t *self, tsk_size_t max_metadata_length_increment) { - if (max_metadata_length_increment == 0) { - max_metadata_length_increment = DEFAULT_SIZE_INCREMENT; - } self->max_metadata_length_increment = max_metadata_length_increment; return 0; } @@ -4617,7 +4622,7 @@ tsk_population_table_init(tsk_population_table_t *self, tsk_flags_t TSK_UNUSED(o } self->metadata_offset[0] = 0; self->max_rows_increment = 0; - self->max_metadata_length_increment = DEFAULT_SIZE_INCREMENT; + self->max_metadata_length_increment = 0; tsk_population_table_set_metadata_schema(self, NULL, 0); out: return ret; @@ -5109,9 +5114,6 @@ int tsk_provenance_table_set_max_timestamp_length_increment( tsk_provenance_table_t *self, tsk_size_t max_timestamp_length_increment) { - if (max_timestamp_length_increment == 0) { - max_timestamp_length_increment = DEFAULT_SIZE_INCREMENT; - } self->max_timestamp_length_increment = max_timestamp_length_increment; return 0; } @@ -5120,9 +5122,6 @@ int tsk_provenance_table_set_max_record_length_increment( tsk_provenance_table_t *self, tsk_size_t max_record_length_increment) { - if (max_record_length_increment == 0) { - max_record_length_increment = DEFAULT_SIZE_INCREMENT; - } self->max_record_length_increment = max_record_length_increment; return 0; } @@ -5153,8 +5152,8 @@ tsk_provenance_table_init(tsk_provenance_table_t *self, tsk_flags_t TSK_UNUSED(o } self->record_offset[0] = 0; self->max_rows_increment = 0; - self->max_timestamp_length_increment = DEFAULT_SIZE_INCREMENT; - self->max_record_length_increment = DEFAULT_SIZE_INCREMENT; + self->max_timestamp_length_increment = 0; + self->max_record_length_increment = 0; out: return ret; }