microsoft/FASTER · warning

WARNING: Ignoring invalid *index* field

Error message

WARNING: Ignoring invalid *index* field '%s'

What it means

The cold index Config constructor parses an [index] TOML table and warns on any key not in its whitelist (table_size, in_mem_size_mb, mutable_fraction). Unknown keys are ignored, meaning the requested cold-index setting is not applied.

Solutions

  1. Use only these keys for the cold index [index] section: table_size, in_mem_size_mb, mutable_fraction
  2. Split cold-index and mem-index settings into separate sections if they need different fields
  3. Remove or rename the offending key

Example fix

// before
[index]
table_size = 4096
mutable_fraction = 0.5
// after (mem index only accepts table_size; move others appropriately)
[index]
table_size = 4096
Defensive patterns

Strategy: validation

Validate before calling

static const std::set<std::string> valid = {"table_size","in_mem_size_mb","mutable_fraction"};
for (const auto& [k, v] : indexTable)
  if (!valid.count(k)) throw std::invalid_argument("invalid cold index field: " + k);

Prevention

When it happens

Trigger: Constructing a cold index Config from a TOML table containing keys other than table_size/in_mem_size_mb/mutable_fraction, e.g. passing a mem-index-style config with mutable_fraction to the cold index or vice versa.

Common situations: Sharing one [index] section between cold and memory index configs, version drift in index options, typos like 'tableSize'.

Understand the failure class

Background: "Invalid value" and "allowed values are" config errors: what your library rejected and how to fix it — this error's family across 41 libraries.

Related errors

AI-assisted analysis of microsoft/FASTER@321d872eab (2026-09-15). Data as JSON: /api/errors/920d5233f75d009a. Report an issue: GitHub.

Appendix: source

Thrown at cc/src/index/cold_index.h:104

  struct Config {
    Config(uint64_t table_size_, uint64_t in_mem_size_, double mutable_fraction_)
      : table_size{ table_size_ }
      , in_mem_size{ in_mem_size_ }
      , mutable_fraction{ mutable_fraction_ } {
    }

    #ifdef TOML_CONFIG
    explicit Config(const toml::value& table) {
      table_size = toml::find<uint64_t>(table, "table_size");
      in_mem_size = toml::find<uint64_t>(table, "in_mem_size_mb") * (1 << 20);
      mutable_fraction = toml::find<double>(table, "mutable_fraction");

      // Warn if unexpected fields are found
      const std::vector<std::string> VALID_INDEX_FIELDS = { "table_size", "in_mem_size_mb", "mutable_fraction" };
      for (auto& it : toml::get<toml::table>(table)) {
        if (std::find(VALID_INDEX_FIELDS.begin(), VALID_INDEX_FIELDS.end(), it.first) == VALID_INDEX_FIELDS.end()) {
          fprintf(stderr, "WARNING: Ignoring invalid *index* field '%s'\n", it.first.c_str());
        }
      }
    }
    #endif

    uint64_t table_size;      // Size of the hash index table
    uint64_t in_mem_size;     // In-memory size of the hlog
    double mutable_fraction;  // Hlog mutable region fraction
  };

  void Initialize(const Config& config) {
    if(!Utility::IsPowerOfTwo(config.table_size)) {
      throw std::invalid_argument{ "Index size is not a power of 2" };
    }
    if(config.table_size > INT32_MAX) {
      throw std::invalid_argument{ "Cannot allocate such a large hash table" };
    }
    this->resize_info.version = 0;

View on GitHub (pinned to 321d872eab)