Ggtcf

the crash happen rarely and i was not able to reproduce it on several android test devices.

the crash report is signal 11 (SIGSEGV), code 1 (SEGV_MAPERR)

can it be the result of UB that happened in a different place in the lifetime of the program? or can you spot an error in the following code?

why std::vector is not in use? execution speed is critical and this is faster, the implementation of the code with vector might been unoptimized and that what caused it to be slower.

what the code does :

create an array of arrays of objects that have a render method

create an int to keep track of the maximum index to use from the first array

create an array of int to keep track of the draw order of the first array

create an array of int to keep track of the capacity of the first array arrays

the code

this is the object function where the crash happen :

each object recursively call his child nodes

Render(GameObject*** container, int* container_keys, int* container_index, int* keys_count)

if (enable == false) return;

if (renderable != nullptr)

 int draw_order_index = -1;
 //search what index is equal to draw_order
 for (int i = 0; i < *keys_count; i++)
 
 if (renderable->draw_order == container_keys[i])
 
 draw_order_index = i;
 break;
 
 

 //add new if not found
 if (draw_order_index == -1)
 
 draw_order_index = *keys_count;

 //size limit determined in initialization 
 if (draw_order_index >= 199) return;

 (*keys_count)++;

 container_keys[draw_order_index] = renderable->draw_order;
 container_index[draw_order_index] = 0;
 

 //how many items in the array
 int container_size = container_index[draw_order_index];

 //size limit determined in initialization 
 if (container_size >= 9999) return;

 //insert new items
 container[draw_order_index][container_size] = this;

 //increase count
 container_index[draw_order_index]++;


for (int i = 0; i < childs_size; i++) 
 childs[i]->Render(container, container_keys, container_index, keys_count);

this is the initialization :

when isRunning set to false, the program terminate

int draw_orders = 200;
int array_size = 10000;

keys_count = 0;

container = new(std::nothrow) GameObject**[draw_orders];
if (container == nullptr) isRunning = false; running_error = 3; return; 

container_keys = new(std::nothrow) int[draw_orders];
if (container_keys == nullptr) isRunning = false; running_error = 4; return; 

container_index = new(std::nothrow) int[draw_orders];
if (container_index == nullptr) isRunning = false; running_error = 5; return; 

for (int i = 0; i < draw_orders; ++i)

 container[i] = new(std::nothrow) GameObject*[array_size];
 if (container[i] == nullptr) isRunning = false; running_error = 6; return; 

this is the call to the root object :

when render_dirty is true the size indexes are set to zero and the data get repopulated and new draw orders get sorted, new draw order priority get sorted once in the lifetime of the program

if (render_dirty == true) 

 for (int i = 0; i < keys_count; i++)
 
 container_index[i] = 0;
 

 RootGameObject->Render(container, container_keys, container_index, &keys_count);
 bool sort = true;
 while (sort)
 
 sort = false;
 for (int i = keys_count - 1; i >= 1; i--)
 
 if (container_keys[i] < container_keys[i - 1])
 
 sort = true;

 int high_draw_order = container_keys[i - 1];
 container_keys[i - 1] = container_keys[i];
 container_keys[i] = high_draw_order;

 int high_index_size = container_index[i - 1];
 container_index[i - 1] = container_index[i];
 container_index[i] = high_index_size;

 GameObject** high_containter = container[i - 1];
 container[i - 1] = container[i];
 container[i] = high_containter;