BUG: StringStore and ListStore resize erase data when the tuple-shape product overflows

Abierto
#1,884 0 comentarios 0 reacciones 0 asignados Ver en GitHub

Los mantenedores suelen responder en 6 días

Nadie ha tomado este issue todavía.

Evaluación

Dificultad
3/5
Tiempo estimado
1-2 días
Aptitud para principiantes
57/100
Tipo de issue
Error
Claridad
Bien especificado
Estado de actividad
Activo
Stack tecnológico
cpp
Área
backend

Línea de trabajo

Read src/simplnx/DataStructure/StringStore.cpp and src/simplnx/DataStructure/ListStore.hpp at the referenced resize functions, then inspect EmptyDataStore::CheckedPlaceholderProduct for zero dimension handling. Add the overflow rejection while preserving the existing store, and apply checked counting in the StringStore shape constructor. Add or run the cases in test/StoreResizeContractsTest.cpp; done means both resizes return error -6035 without changing shape, tuple count, or values.

Escrito por el modelo de indexación a partir del texto del issue.

Descripción

bug

Problem

StringStore::resizeTuples() and ListStore::resizeTuples() do not check the tuple-shape product for overflow. When the product does not fit in usize, it wraps around. The resize then deletes the stored values, records the requested shape, and returns a valid Result<>.

For example, a StringStore with 3 strings that is resized to the tuple shape {2^63, 2} on a 64-bit platform returns success. After the call, it has 0 tuples and no strings, but getTupleShape() returns {9223372036854775808, 2}. ListStore behaves in the same way.

The expected behavior is the documented contract of resizeTuples(): return error -6035 and keep the prior store (shape, tuple count and values).

Occurs at develop commit 547f28a75e6325358fe7823e6dcb00defda81cd1.

Steps to Reproduce

  1. Build simplnx_test from develop (Release, 64-bit).
  2. Add the two tests in Verification Unit Test to test/StoreResizeContractsTest.cpp.
  3. Make a StringStore with the strings "alpha", "beta" and "gamma" and the tuple shape {3}.
  4. Call resizeTuples({usize{1} << 63, 2}).
  5. The call returns a valid Result<>, the store has 0 tuples, and the tuple shape is {9223372036854775808, 2}.
  6. Do steps 3 to 5 again with a ListStore<int32> that has 3 lists. The result is the same.

Cause

Both functions compute the tuple count with std::accumulate and no overflow check, and then resize the container to the wrapped count:

https://github.com/BlueQuartzSoftware/simplnx/blob/547f28a75e6325358fe7823e6dcb00defda81cd1/src/simplnx/DataStructure/StringStore.cpp#L41-L55

https://github.com/BlueQuartzSoftware/simplnx/blob/547f28a75e6325358fe7823e6dcb00defda81cd1/src/simplnx/DataStructure/ListStore.hpp#L129-L144

const usize numTuples = std::accumulate(newTupleShape.cbegin(), newTupleShape.cend(), static_cast<usize>(1), std::multiplies<>());
m_Data.resize(numTuples);            // m_Array.resize(numTuples) in ListStore
m_TupleShape = std::move(newTupleShape);
m_NumTuples = numTuples;

2^63 * 2 is 2^64, which wraps to 0. resize(0) succeeds and deletes every element, so the catch block that returns -6035 never runs.

The StringStore(const ShapeType& tupleShape) constructor computes the count in the same way (StringStore.cpp L16).

Verification Unit Test

File: test/StoreResizeContractsTest.cpp

TEST_CASE("StringStore resize rejects an overflowing tuple shape", "[simplnx][StoreResizeContracts]")
{
  StringStore store(std::vector<std::string>{"alpha", "beta", "gamma"}, ShapeType{3});
  // The tuple-shape product 2^63 * 2 = 2^64 does not fit a 64-bit usize.
  const ShapeType overflowingTupleShape = {usize{1} << 63, 2};

  Result<> result;
  REQUIRE_NOTHROW(result = store.resizeTuples(overflowingTupleShape));
  CHECK(result.invalid());
  CHECK(store.getTupleShape() == ShapeType{3});
  REQUIRE(store.getNumberOfTuples() == 3);
  CHECK(store.getValue(0) == "alpha");
  CHECK(store.getValue(1) == "beta");
  CHECK(store.getValue(2) == "gamma");
  REQUIRE(result.errors().size() == 1);
  CHECK(result.errors().front().code == -6035);
}

TEST_CASE("ListStore resize rejects an overflowing tuple shape", "[simplnx][StoreResizeContracts]")
{
  ListStore<int32> store(ShapeType{3});
  store.setList(0, std::vector<int32>{7, 9});
  store.setList(1, std::vector<int32>{-4});
  store.setList(2, std::vector<int32>{1, 2, 3});
  // The tuple-shape product 2^63 * 2 = 2^64 does not fit a 64-bit usize.
  const ShapeType overflowingTupleShape = {usize{1} << 63, 2};

  Result<> result;
  REQUIRE_NOTHROW(result = store.resizeTuples(overflowingTupleShape));
  CHECK(result.invalid());
  CHECK(store.getTupleShape() == ShapeType{3});
  REQUIRE(store.getNumberOfTuples() == 3);
  CHECK(store.getList(0) == std::vector<int32>{7, 9});
  CHECK(store.getList(1) == std::vector<int32>{-4});
  CHECK(store.getList(2) == std::vector<int32>{1, 2, 3});
  REQUIRE(result.errors().size() == 1);
  CHECK(result.errors().front().code == -6035);
}

Command (from the build directory):

ctest -R "^(StringStore|ListStore) resize rejects an overflowing tuple shape$" --output-on-failure

Failure on develop (macOS arm64, AppleClang, Release). ListStore fails with the same three lines at L127-L129:

StoreResizeContractsTest.cpp:106: FAILED:
  CHECK( result.invalid() )
with expansion:
  false
StoreResizeContractsTest.cpp:107: FAILED:
  CHECK( store.getTupleShape() == ShapeType{3} )
with expansion:
  { 9223372036854775808 (0x8000000000000000), 2 } == { 3 }
StoreResizeContractsTest.cpp:108: FAILED:
  REQUIRE( store.getNumberOfTuples() == 3 )
with expansion:
  0 == 3
0% tests passed, 2 tests failed out of 2

Proposed Fix

  • In StringStore::resizeTuples() and ListStore::resizeTuples(), compute the tuple count with an overflow check before resize(). On overflow, return error -6035 with a message that says the tuple count does not fit, and do not change the store.
  • A shape that contains a zero dimension has a count of zero. Check for a zero dimension before the multiplication, as EmptyDataStore::CheckedPlaceholderProduct does, so that {SIZE_MAX, 2, 0} resizes to 0 tuples.
  • Use the same check in the StringStore(const ShapeType&) constructor, and throw there because a constructor cannot return a Result<>.
  • A shared checked-product helper for all stores would keep the rule the same everywhere.

Notes

  • PR #1834 adds this check to DataStore::resizeTuples() only.
  • The DataStore constructors have the same unchecked product (#1883).
Lenguaje dominante
C++
Estrellas
18
Forks
15
Merge medio
4 d 23 h
PR fusionados (30 d)
42

Preparar el entorno

Primeros pasos

  1. Lee el issue completo y luego la guía de contribución del proyecto.
  2. Comenta en el issue que vas a ocuparte — evita que dos personas hagan lo mismo.
  3. Haz un fork del repositorio y trabaja en una rama.
  4. Abre un pull request que haga referencia al número del issue.

Más de BlueQuartzSoftware/simplnx

Todos los issues de BlueQuartzSoftware/simplnx

Issues similares

Más issues de C++

Recibe los nuevos issues en tu correo

Un resumen breve de issues de GitHub para principiantes.