i added "fir's" by analogy to "fir's" c dictionary (such arrays in c are simple concept but somewhat not known i guess (becouse if they would be known they would be talked and for exampel on thsi group never seen it talked, in other parts of internet world i know - i dont seen them to) )

note i decided to array that just uses reallock to grow up as resizable
becouse its resizable but not offer an ability to delete records_
by dynamic i would mean this one that offers deletion
(and by convenience also is resizable - there are two options of
this one that offers deletion, may be done on static ram or may
be done by reallock seed and be resizable - i think both of them may be called resizable)

first time i made a test of time of resizable (more thest of dynamic etc) i will do later as im tired

struct Agent {int enabled; float x,y,r;};

Agent agent_static[1000000];
int AddAgentStatic(float x,float y, float r)
{ static int it =0;
agent_static[it].x = x;
agent_static[it].y = y;
agent_static[it].r = r;
it++;

}
void AddAgentsStaticArray(int n)
{ for(int i=0; i<n;i++) AddAgentStatic(i,2.0,3.0);
}

//////////////////////
Agent* agent = NULL;
int agent_size = 0;
int AddAgent(float x,float y, float r)
{ agent = (Agent*) realloc(agent, ++agent_size*sizeof(Agent) );

agent[agent_size-1].x = x;
agent[agent_size-1].y = y;
agent[agent_size-1].r = r;

}
void AddAgentsResizableArray(int n)
{ for(int i=0; i<n;i++) AddAgent(i,2.0,3.0);
}

/////////////////////////////////

void make_test(int n)
{ double t;

TakeDeltaTimeNS(1);
AddAgentsStaticArray(n);
t = TakeDeltaTimeNS(1);
printf("\n static for n %d in %f microsecond", n, t/1000 );

TakeDeltaTimeNS(1);
AddAgentsResizableArray(1000);
t = TakeDeltaTimeNS(1);
printf("\n dynamic for n %d in %f microsecond", n, t/1000 );

}

int main()
{ for(int i=0; i<10;i++) make_test(1000);

return 1;
}

the results

static for n 1000 in 8.601319 microsecond
dynamic for n 1000 in 146.977294 microsecond
static for n 1000 in 10.044897 microsecond
dynamic for n 1000 in 146.336706 microsecond
static for n 1000 in 10.285493 microsecond
dynamic for n 1000 in 169.259522 microsecond
static for n 1000 in 10.186247 microsecond
dynamic for n 1000 in 149.996778 microsecond
static for n 1000 in 10.102039 microsecond
dynamic for n 1000 in 143.512706 microsecond
static for n 1000 in 10.195270 microsecond
dynamic for n 1000 in 144.032996 microsecond
static for n 1000 in 10.002793 microsecond
dynamic for n 1000 in 145.602887 microsecond
static for n 1000 in 9.936629 microsecond
dynamic for n 1000 in 145.551760 microsecond
static for n 1000 in 9.981740 microsecond
dynamic for n 1000 in 145.034478 microsecond
static for n 1000 in 9.930614 microsecond
dynamic for n 1000 in 149.335138 microsecond

it is worste (i mean resizable) than i thought coz imo this is
logically not much need for it to be that slow maybe ..
it si becouse reallock my do nothing most times or
only do mamcopies/memoves sporadically i would need to
make test what is the reason

not initially when i was doint that test of resizable arrays (when dealing with my chunk library (sickle.c) i did it this way i use the int for keeping the most reallocks away and only reallock it logarythmically - but then i decided to drop it becouse reallock manages it itself..mut now i would need to insight it again i guess

niedziela, 6 sierpnia 2023 o 18:06:23 UTC+2 fir napisał(a):
>
> note i decided to array that just uses reallock to grow up as resizable

errata: it was menat to be "i decided to name array"

> becouse its resizable but not offer an ability to delete records_
> by dynamic i would mean this one that offers deletion
> (and by convenience also is resizable - there are two options of
> this one that offers deletion, may be done on static ram or may
> be done by reallock seed and be resizable - i think both of them may be called resizable)

" both of them may be called dynamic"

(though this naming my change becouse this one that offers adds and removes may be static based but imo the ability to repeatable insertions and removations makes it more dynamic then ability to grow and shrink (maybe)...well at least its hard to decide which one of thsi ability to name by "dynamicity")

niedziela, 6 sierpnia 2023 o 18:14:15 UTC+2 fir napisał(a):
> niedziela, 6 sierpnia 2023 o 18:06:23 UTC+2 fir napisał(a):
> >
> > note i decided to array that just uses reallock to grow up as resizable
> errata: it was menat to be "i decided to name array"
> > becouse its resizable but not offer an ability to delete records_
> > by dynamic i would mean this one that offers deletion
> > (and by convenience also is resizable - there are two options of
> > this one that offers deletion, may be done on static ram or may
> > be done by reallock seed and be resizable - i think both of them may be called resizable)
> " both of them may be called dynamic"
>
> (though this naming my change becouse this one that offers adds and removes may be static based but imo the ability to repeatable insertions and removations makes it more dynamic then ability to grow and shrink (maybe)...well at least its hard to decide which one of thsi ability to name by "dynamicity")

well meybe to spare confusion its better for now not to use words resizable and dynamic but mabye "growing" and "inserting "

niedziela, 6 sierpnia 2023 o 18:06:23 UTC+2 fir napisał(a):
>
> it is worste (i mean resizable) than i thought coz imo this is
> logically not much need for it to be that slow maybe ..
> it si becouse reallock my do nothing most times or
> only do mamcopies/memoves sporadically i would need to
> make test what is the reason
>
> not initially when i was doint that test of resizable arrays (when dealing with my chunk library (sickle.c) i did it this way i use the int for keeping the most reallocks away and only reallock it logarythmically - but then i decided to drop it becouse reallock manages it itself..mut now i would need to insight it again i guess

the results in respect to N

N 0 adds: static 0.3 dynamic 147.5 micro
N 20 adds: static 0.5 dynamic 171.1 micro
N 40 adds: static 0.5 dynamic 143.9 micro
N 60 adds: static 0.5 dynamic 145.7 micro
N 80 adds: static 0.6 dynamic 146.1 micro
N 100 adds: static 3.6 dynamic 142.0 micro
N 120 adds: static 0.8 dynamic 142.5 micro
N 140 adds: static 3.5 dynamic 143.1 micro
N 160 adds: static 1.0 dynamic 141.8 micro
N 180 adds: static 2.8 dynamic 142.9 micro
N 200 adds: static 2.7 dynamic 141.6 micro
N 220 adds: static 3.0 dynamic 143.4 micro
N 240 adds: static 2.9 dynamic 145.0 micro
N 260 adds: static 3.2 dynamic 141.4 micro
N 280 adds: static 3.2 dynamic 143.9 micro
N 300 adds: static 3.1 dynamic 141.2 micro
N 320 adds: static 4.2 dynamic 143.3 micro
N 340 adds: static 4.4 dynamic 144.1 micro
N 360 adds: static 7.0 dynamic 141.4 micro
N 380 adds: static 3.7 dynamic 144.4 micro
N 400 adds: static 6.4 dynamic 141.2 micro
N 420 adds: static 5.4 dynamic 140.1 micro
N 440 adds: static 3.7 dynamic 141.2 micro
N 460 adds: static 5.6 dynamic 142.4 micro
N 480 adds: static 5.7 dynamic 141.5 micro
N 500 adds: static 5.4 dynamic 142.0 micro
N 520 adds: static 6.8 dynamic 142.5 micro
N 540 adds: static 5.7 dynamic 143.8 micro
N 560 adds: static 6.9 dynamic 144.7 micro
N 580 adds: static 7.9 dynamic 144.6 micro
N 600 adds: static 7.7 dynamic 144.5 micro
N 620 adds: static 6.3 dynamic 143.4 micro
N 640 adds: static 7.9 dynamic 971.6 micro
N 660 adds: static 7.6 dynamic 1639.9 micro
N 680 adds: static 10.0 dynamic 1839.4 micro
N 700 adds: static 11.0 dynamic 1973.4 micro
N 720 adds: static 14.6 dynamic 2237.5 micro
N 740 adds: static 15.8 dynamic 2122.9 micro
N 760 adds: static 10.8 dynamic 2240.1 micro
N 780 adds: static 19.3 dynamic 2345.4 micro
N 800 adds: static 17.4 dynamic 2736.0 micro
N 820 adds: static 15.1 dynamic 2535.7 micro
N 840 adds: static 14.2 dynamic 2070.4 micro
N 860 adds: static 14.6 dynamic 10308.4 micro
N 880 adds: static 16.5 dynamic 2733.2 micro
N 900 adds: static 12.2 dynamic 3054.4 micro
N 920 adds: static 19.7 dynamic 3240.5 micro
N 940 adds: static 19.1 dynamic 3232.7 micro
N 960 adds: static 16.8 dynamic 3360.4 micro
N 980 adds: static 19.4 dynamic 3383.3 micro
N 1000 adds: static 18.3 dynamic 3601.0 micro
N 1020 adds: static 19.9 dynamic 3674.3 micro
N 1040 adds: static 20.3 dynamic 3802.7 micro
N 1060 adds: static 18.7 dynamic 2908.0 micro
N 1080 adds: static 22.6 dynamic 3696.7 micro
N 1100 adds: static 19.8 dynamic 4536.3 micro
N 1120 adds: static 19.5 dynamic 3840.9 micro
N 1140 adds: static 22.3 dynamic 4093.5 micro
N 1160 adds: static 20.0 dynamic 4076.8 micro
N 1180 adds: static 27.0 dynamic 4170.0 micro
N 1200 adds: static 21.0 dynamic 4489.9 micro
N 1220 adds: static 23.4 dynamic 4548.7 micro
N 1240 adds: static 23.2 dynamic 4665.7 micro
N 1260 adds: static 22.9 dynamic 4225.0 micro
N 1280 adds: static 22.1 dynamic 3747.0 micro
N 1300 adds: static 22.7 dynamic 20198.9 micro
N 1320 adds: static 29.9 dynamic 4576.6 micro
N 1340 adds: static 22.9 dynamic 5330.6 micro
N 1360 adds: static 28.1 dynamic 4903.3 micro
N 1380 adds: static 24.1 dynamic 4986.5 micro
N 1400 adds: static 26.4 dynamic 5142.4 micro
N 1420 adds: static 22.2 dynamic 5059.9 micro
N 1440 adds: static 27.0 dynamic 5545.3 micro
N 1460 adds: static 29.5 dynamic 5405.8 micro
N 1480 adds: static 21.8 dynamic 4060.7 micro
N 1500 adds: static 33.8 dynamic 5610.5 micro
N 1520 adds: static 27.8 dynamic 5506.4 micro
N 1540 adds: static 26.4 dynamic 6044.5 micro
N 1560 adds: static 35.4 dynamic 6112.0 micro
N 1580 adds: static 30.4 dynamic 5088.4 micro
N 1600 adds: static 31.9 dynamic 5600.4 micro
N 1620 adds: static 29.9 dynamic 5524.0 micro
N 1640 adds: static 28.3 dynamic 5505.7 micro
N 1660 adds: static 34.0 dynamic 5638.4 micro
N 1680 adds: static 30.3 dynamic 5695.7 micro
N 1700 adds: static 30.8 dynamic 4215.4 micro
N 1720 adds: static 30.8 dynamic 5706.4 micro
N 1740 adds: static 30.3 dynamic 5813.0 micro
N 1760 adds: static 29.0 dynamic 6036.9 micro
N 1780 adds: static 33.4 dynamic 5946.6 micro
N 1800 adds: static 32.4 dynamic 6048.5 micro
N 1820 adds: static 38.7 dynamic 5987.9 micro
N 1840 adds: static 33.3 dynamic 6129.2 micro
N 1860 adds: static 32.1 dynamic 6300.9 micro
N 1880 adds: static 36.2 dynamic 6330.7 micro
N 1900 adds: static 34.9 dynamic 6331.9 micro
N 1920 adds: static 32.6 dynamic 4884.5 micro
N 1940 adds: static 34.6 dynamic 6539.2 micro
N 1960 adds: static 23.1 dynamic 12085.5 micro
N 1980 adds: static 27.0 dynamic 6105.1 micro
N 2000 adds: static 35.8 dynamic 6917.7 micro
N 2020 adds: static 35.0 dynamic 6875.9 micro
N 2040 adds: static 140.6 dynamic 6887.4 micro
N 2060 adds: static 33.9 dynamic 7079.3 micro
N 2080 adds: static 27.2 dynamic 6781.1 micro

niedziela, 6 sierpnia 2023 o 18:36:41 UTC+2 fir napisał(a):
> niedziela, 6 sierpnia 2023 o 18:06:23 UTC+2 fir napisał(a):
> >
> > it is worste (i mean resizable) than i thought coz imo this is
> > logically not much need for it to be that slow maybe ..
> > it si becouse reallock my do nothing most times or
> > only do mamcopies/memoves sporadically i would need to
> > make test what is the reason
> >
> > not initially when i was doint that test of resizable arrays (when dealing with my chunk library (sickle.c) i did it this way i use the int for keeping the most reallocks away and only reallock it logarythmically - but then i decided to drop it becouse reallock manages it itself..mut now i would need to insight it again i guess
> the results in respect to N
>
>
> N 0 adds: static 0.3 dynamic 147.5 micro
> N 20 adds: static 0.5 dynamic 171.1 micro
> N 40 adds: static 0.5 dynamic 143.9 micro
> N 60 adds: static 0.5 dynamic 145.7 micro
> N 80 adds: static 0.6 dynamic 146.1 micro
> N 100 adds: static 3.6 dynamic 142.0 micro
> N 120 adds: static 0.8 dynamic 142.5 micro
> N 140 adds: static 3.5 dynamic 143.1 micro
> N 160 adds: static 1.0 dynamic 141.8 micro
> N 180 adds: static 2.8 dynamic 142.9 micro
> N 200 adds: static 2.7 dynamic 141.6 micro
> N 220 adds: static 3.0 dynamic 143.4 micro
> N 240 adds: static 2.9 dynamic 145.0 micro
> N 260 adds: static 3.2 dynamic 141.4 micro
> N 280 adds: static 3.2 dynamic 143.9 micro
> N 300 adds: static 3.1 dynamic 141.2 micro
> N 320 adds: static 4.2 dynamic 143.3 micro
> N 340 adds: static 4.4 dynamic 144.1 micro
> N 360 adds: static 7.0 dynamic 141.4 micro
> N 380 adds: static 3.7 dynamic 144.4 micro
> N 400 adds: static 6.4 dynamic 141.2 micro
> N 420 adds: static 5.4 dynamic 140.1 micro
> N 440 adds: static 3.7 dynamic 141.2 micro
> N 460 adds: static 5.6 dynamic 142.4 micro
> N 480 adds: static 5.7 dynamic 141.5 micro
> N 500 adds: static 5.4 dynamic 142.0 micro
> N 520 adds: static 6.8 dynamic 142.5 micro
> N 540 adds: static 5.7 dynamic 143.8 micro
> N 560 adds: static 6.9 dynamic 144.7 micro
> N 580 adds: static 7.9 dynamic 144.6 micro
> N 600 adds: static 7.7 dynamic 144.5 micro
> N 620 adds: static 6.3 dynamic 143.4 micro
> N 640 adds: static 7.9 dynamic 971.6 micro
> N 660 adds: static 7.6 dynamic 1639.9 micro
> N 680 adds: static 10.0 dynamic 1839.4 micro
> N 700 adds: static 11.0 dynamic 1973.4 micro
> N 720 adds: static 14.6 dynamic 2237.5 micro
> N 740 adds: static 15.8 dynamic 2122.9 micro
> N 760 adds: static 10.8 dynamic 2240.1 micro
> N 780 adds: static 19.3 dynamic 2345.4 micro
> N 800 adds: static 17.4 dynamic 2736.0 micro
> N 820 adds: static 15.1 dynamic 2535.7 micro
> N 840 adds: static 14.2 dynamic 2070.4 micro
> N 860 adds: static 14.6 dynamic 10308.4 micro
> N 880 adds: static 16.5 dynamic 2733.2 micro
> N 900 adds: static 12.2 dynamic 3054.4 micro
> N 920 adds: static 19.7 dynamic 3240.5 micro
> N 940 adds: static 19.1 dynamic 3232.7 micro
> N 960 adds: static 16.8 dynamic 3360.4 micro
> N 980 adds: static 19.4 dynamic 3383.3 micro
> N 1000 adds: static 18.3 dynamic 3601.0 micro
> N 1020 adds: static 19.9 dynamic 3674.3 micro
> N 1040 adds: static 20.3 dynamic 3802.7 micro
> N 1060 adds: static 18.7 dynamic 2908.0 micro
> N 1080 adds: static 22.6 dynamic 3696.7 micro
> N 1100 adds: static 19.8 dynamic 4536.3 micro
> N 1120 adds: static 19.5 dynamic 3840.9 micro
> N 1140 adds: static 22.3 dynamic 4093.5 micro
> N 1160 adds: static 20.0 dynamic 4076.8 micro
> N 1180 adds: static 27.0 dynamic 4170.0 micro
> N 1200 adds: static 21.0 dynamic 4489.9 micro
> N 1220 adds: static 23.4 dynamic 4548.7 micro
> N 1240 adds: static 23.2 dynamic 4665.7 micro
> N 1260 adds: static 22.9 dynamic 4225.0 micro
> N 1280 adds: static 22.1 dynamic 3747.0 micro
> N 1300 adds: static 22.7 dynamic 20198.9 micro
> N 1320 adds: static 29.9 dynamic 4576.6 micro
> N 1340 adds: static 22.9 dynamic 5330.6 micro
> N 1360 adds: static 28.1 dynamic 4903.3 micro
> N 1380 adds: static 24.1 dynamic 4986.5 micro
> N 1400 adds: static 26.4 dynamic 5142.4 micro
> N 1420 adds: static 22.2 dynamic 5059.9 micro
> N 1440 adds: static 27.0 dynamic 5545.3 micro
> N 1460 adds: static 29.5 dynamic 5405.8 micro
> N 1480 adds: static 21.8 dynamic 4060.7 micro
> N 1500 adds: static 33.8 dynamic 5610.5 micro
> N 1520 adds: static 27.8 dynamic 5506.4 micro
> N 1540 adds: static 26.4 dynamic 6044.5 micro
> N 1560 adds: static 35.4 dynamic 6112.0 micro
> N 1580 adds: static 30.4 dynamic 5088.4 micro
> N 1600 adds: static 31.9 dynamic 5600.4 micro
> N 1620 adds: static 29.9 dynamic 5524.0 micro
> N 1640 adds: static 28.3 dynamic 5505.7 micro
> N 1660 adds: static 34.0 dynamic 5638.4 micro
> N 1680 adds: static 30.3 dynamic 5695.7 micro
> N 1700 adds: static 30.8 dynamic 4215.4 micro
> N 1720 adds: static 30.8 dynamic 5706.4 micro
> N 1740 adds: static 30.3 dynamic 5813.0 micro
> N 1760 adds: static 29.0 dynamic 6036.9 micro
> N 1780 adds: static 33.4 dynamic 5946.6 micro
> N 1800 adds: static 32.4 dynamic 6048.5 micro
> N 1820 adds: static 38.7 dynamic 5987.9 micro
> N 1840 adds: static 33.3 dynamic 6129.2 micro
> N 1860 adds: static 32.1 dynamic 6300.9 micro
> N 1880 adds: static 36.2 dynamic 6330.7 micro
> N 1900 adds: static 34.9 dynamic 6331.9 micro
> N 1920 adds: static 32.6 dynamic 4884.5 micro
> N 1940 adds: static 34.6 dynamic 6539.2 micro
> N 1960 adds: static 23.1 dynamic 12085.5 micro
> N 1980 adds: static 27.0 dynamic 6105.1 micro
> N 2000 adds: static 35.8 dynamic 6917.7 micro
> N 2020 adds: static 35.0 dynamic 6875.9 micro
> N 2040 adds: static 140.6 dynamic 6887.4 micro
> N 2060 adds: static 33.9 dynamic 7079.3 micro
> N 2080 adds: static 27.2 dynamic 6781.1 micro

note when i added this flag to spare realllocks and mke them call logarythmically

Agent* agent = NULL; int agent_size = 0; int agent_last_reallockd = 0;

int AddAgent(float x,float y, float r)
{ if(++agent_size > agent_last_reallockd)
agent = (Agent*) realloc(agent, (agent_last_reallockd = 2*agent_size)*sizeof(Agent) );

agent[agent_size-1].x = x; agent[agent_size-1].y = y; agent[agent_size-1].r = r;

}
the results are

N 0 adds: static 0.3 dynamic 24.7 micro
N 20 adds: static 0.4 dynamic 26.5 micro
N 40 adds: static 0.5 dynamic 30.7 micro
N 60 adds: static 0.5 dynamic 12.4 micro
N 80 adds: static 0.6 dynamic 54.3 micro
N 100 adds: static 2.5 dynamic 11.9 micro
N 120 adds: static 0.7 dynamic 12.1 micro
N 140 adds: static 2.5 dynamic 11.0 micro
N 160 adds: static 0.9 dynamic 86.1 micro
N 180 adds: static 2.6 dynamic 12.1 micro
N 200 adds: static 2.6 dynamic 11.2 micro
N 220 adds: static 2.7 dynamic 12.2 micro
N 240 adds: static 2.7 dynamic 12.0 micro
N 260 adds: static 2.8 dynamic 12.3 micro
N 280 adds: static 3.2 dynamic 12.4 micro
N 300 adds: static 2.9 dynamic 12.3 micro
N 320 adds: static 3.1 dynamic 161.6 micro
N 340 adds: static 3.2 dynamic 12.0 micro
N 360 adds: static 4.8 dynamic 12.3 micro
N 380 adds: static 3.2 dynamic 12.3 micro
N 400 adds: static 4.9 dynamic 12.3 micro
N 420 adds: static 4.9 dynamic 11.3 micro
N 440 adds: static 3.5 dynamic 12.4 micro
N 460 adds: static 5.1 dynamic 12.3 micro
N 480 adds: static 5.1 dynamic 12.2 micro
N 500 adds: static 5.1 dynamic 12.3 micro
N 520 adds: static 5.2 dynamic 12.4 micro
N 540 adds: static 5.4 dynamic 12.4 micro
N 560 adds: static 5.7 dynamic 12.2 micro
N 580 adds: static 5.6 dynamic 12.1 micro
N 600 adds: static 7.0 dynamic 12.2 micro
N 620 adds: static 5.7 dynamic 12.2 micro
N 640 adds: static 7.3 dynamic 307.8 micro
N 660 adds: static 6.1 dynamic 12.4 micro
N 680 adds: static 7.6 dynamic 12.2 micro
N 700 adds: static 8.0 dynamic 12.3 micro
N 720 adds: static 7.8 dynamic 12.2 micro
N 740 adds: static 6.5 dynamic 22.7 micro
N 760 adds: static 9.7 dynamic 13.6 micro
N 780 adds: static 9.2 dynamic 13.1 micro
N 800 adds: static 11.4 dynamic 13.6 micro
N 820 adds: static 10.1 dynamic 13.4 micro
N 840 adds: static 9.4 dynamic 11.8 micro
N 860 adds: static 9.0 dynamic 13.4 micro
N 880 adds: static 11.5 dynamic 13.4 micro
N 900 adds: static 9.5 dynamic 13.2 micro
N 920 adds: static 10.2 dynamic 13.2 micro
N 940 adds: static 17.0 dynamic 17.8 micro
N 960 adds: static 15.2 dynamic 17.6 micro
N 980 adds: static 18.0 dynamic 17.7 micro
N 1000 adds: static 17.4 dynamic 18.6 micro
N 1020 adds: static 18.1 dynamic 17.8 micro
N 1040 adds: static 18.3 dynamic 18.7 micro
N 1060 adds: static 18.9 dynamic 16.9 micro
N 1080 adds: static 21.1 dynamic 18.8 micro
N 1100 adds: static 20.3 dynamic 19.3 micro
N 1120 adds: static 20.0 dynamic 19.8 micro
N 1140 adds: static 22.5 dynamic 20.5 micro
N 1160 adds: static 11.8 dynamic 12.5 micro
N 1180 adds: static 12.6 dynamic 12.3 micro
N 1200 adds: static 10.8 dynamic 12.4 micro
N 1220 adds: static 12.5 dynamic 12.2 micro
N 1240 adds: static 12.8 dynamic 12.6 micro
N 1260 adds: static 13.0 dynamic 12.3 micro
N 1280 adds: static 13.0 dynamic 11.3 micro
N 1300 adds: static 12.9 dynamic 677.6 micro
N 1320 adds: static 14.1 dynamic 12.2 micro
N 1340 adds: static 13.5 dynamic 12.6 micro
N 1360 adds: static 15.0 dynamic 12.3 micro
N 1380 adds: static 13.5 dynamic 13.4 micro
N 1400 adds: static 14.9 dynamic 12.4 micro
N 1420 adds: static 13.8 dynamic 12.5 micro
N 1440 adds: static 15.5 dynamic 12.2 micro
N 1460 adds: static 15.2 dynamic 12.4 micro
N 1480 adds: static 14.1 dynamic 11.5 micro
N 1500 adds: static 15.7 dynamic 12.4 micro
N 1520 adds: static 15.5 dynamic 12.7 micro
N 1540 adds: static 15.8 dynamic 12.5 micro
N 1560 adds: static 16.1 dynamic 12.7 micro
N 1580 adds: static 15.7 dynamic 12.2 micro
N 1600 adds: static 17.8 dynamic 12.4 micro
N 1620 adds: static 17.0 dynamic 12.4 micro
N 1640 adds: static 16.4 dynamic 12.5 micro
N 1660 adds: static 17.9 dynamic 12.5 micro
N 1680 adds: static 17.0 dynamic 12.3 micro
N 1700 adds: static 18.2 dynamic 11.4 micro
N 1720 adds: static 19.8 dynamic 12.4 micro
N 1740 adds: static 19.2 dynamic 12.6 micro
N 1760 adds: static 17.8 dynamic 12.4 micro
N 1780 adds: static 18.9 dynamic 12.3 micro
N 1800 adds: static 18.9 dynamic 12.4 micro
N 1820 adds: static 20.2 dynamic 12.7 micro
N 1840 adds: static 19.7 dynamic 12.2 micro
N 1860 adds: static 20.6 dynamic 12.2 micro
N 1880 adds: static 20.2 dynamic 16.5 micro
N 1900 adds: static 22.2 dynamic 12.3 micro
N 1920 adds: static 20.6 dynamic 11.4 micro
N 1940 adds: static 22.0 dynamic 12.6 micro
N 1960 adds: static 19.7 dynamic 12.7 micro
N 1980 adds: static 23.3 dynamic 12.5 micro
N 2000 adds: static 22.0 dynamic 12.4 micro
N 2020 adds: static 22.9 dynamic 12.5 micro
N 2040 adds: static 22.8 dynamic 12.6 micro
N 2060 adds: static 22.0 dynamic 12.4 micro
N 2080 adds: static 23.4 dynamic 12.5 micro

ye there was two errors in last test (i nor resetted the position and i pun 1000 or somenthing in dynamic instead of N)

now my test of
int AddAgent(float x,float y, float r)
{ if(++agent_size > agent_last_reallockd)
agent = (Agent*) realloc(agent, (agent_last_reallockd = 2*agent_size+100)*sizeof(Agent) );

agent[agent_size-1].x = x; agent[agent_size-1].y = y; agent[agent_size-1].r = r;
}

show

N 0 adds: static 0.3 dynamic 0.2 micro
N 1000 adds: static 8.7 dynamic 24.8 micro
N 2000 adds: static 13.7 dynamic 35.8 micro
N 3000 adds: static 16.8 dynamic 44.1 micro
N 4000 adds: static 20.2 dynamic 85.6 micro
N 5000 adds: static 23.7 dynamic 97.2 micro
N 6000 adds: static 27.3 dynamic 109.0 micro
N 7000 adds: static 35.1 dynamic 177.6 micro
N 8000 adds: static 34.0 dynamic 190.0 micro
N 9000 adds: static 37.3 dynamic 203.1 micro
N 10000 adds: static 40.8 dynamic 214.7 micro
N 11000 adds: static 44.8 dynamic 323.5 micro
N 12000 adds: static 58.3 dynamic 339.7 micro
N 13000 adds: static 60.6 dynamic 474.0 micro
N 14000 adds: static 54.3 dynamic 368.5 micro
N 15000 adds: static 57.6 dynamic 512.3 micro
N 16000 adds: static 73.2 dynamic 507.2 micro
N 17000 adds: static 64.7 dynamic 401.4 micro
N 18000 adds: static 67.5 dynamic 421.6 micro
N 19000 adds: static 71.1 dynamic 433.5 micro
N 20000 adds: static 75.1 dynamic 474.2 micro
N 21000 adds: static 94.8 dynamic 634.7 micro
N 22000 adds: static 101.1 dynamic 657.3 micro
N 94000 adds: static 837.3 dynamic 3479.6 micro
N 95000 adds: static 1233.9 dynamic 4937.1 micro
N 96000 adds: static 861.8 dynamic 3085.1 micro
N 97000 adds: static 1116.5 dynamic 3271.9 micro
N 98000 adds: static 959.4 dynamic 3210.3 micro
N 99000 adds: static 936.6 dynamic 3137.6 micro

its about 3-4 times slower so its possibly standable, dont know if this a cost of this if or those sporadic reallocks...i think the overhead of reallock also my come form calling this in dll or
something..so though logically reallock should cahe it itself it is practically better it seems to use that if client side

//////////STATIC
struct Agent {int enabled; float x,y,r;};

Agent agent_static[1000000];
int agent_static_it =0;

int AddAgentStatic(float x,float y, float r) { agent_static[agent_static_it++] = {1,x,y,r};}
void AddAgentsStaticArray(int n) { for(int i=0; i<n;i++) AddAgentStatic(i,2.0,3.0);}

////////////////GROWING

Agent* agent = NULL; int agent_size = 0; int agent_last_reallockd = 0;

int AddAgent(float x,float y, float r)
{ if(++agent_size > agent_last_reallockd) agent = (Agent*) realloc(agent, (agent_last_reallockd = 2*agent_size+100)*sizeof(Agent) );
agent[agent_size-1] = {1,x,y,r};
}

void AddAgentsResizableArray(int n) { for(int i=0; i<n;i++) AddAgent(i,2.0,3.0);}

/////////////////////////////////
void make_containers_test(int n)
{ double ts,td;
agent_static_it = 0;
agent_size = 0; agent_last_reallockd = 0; agent = (Agent*) realloc(agent, 0 );

TakeDeltaTimeNS(1); AddAgentsStaticArray(n); ts = TakeDeltaTimeNS(1);
TakeDeltaTimeNS(1); AddAgentsResizableArray(n); td = TakeDeltaTimeNS(1);
printf("\n N %d adds: static %.1f dynamic %.1f micro (%.1f / %.1f NS per one) ", n, ts/1000, td/1000, ts/n, td/n );

}

int main() { for(int i=0; i<=100000;i+=1000) make_containers_test(i); return 1;}

and the results (those are somewhat slower as i changed to insert 16 byte structures instead 12 bytes previously)

N 0 adds: static 0.3 dynamic 0.3 micro (1.$ / 1.$ NS per one)
N 1000 adds: static 9.1 dynamic 25.1 micro (9.1 / 25.1 NS per one)
N 2000 adds: static 14.2 dynamic 37.3 micro (7.1 / 18.7 NS per one)
N 3000 adds: static 22.8 dynamic 47.2 micro (7.6 / 15.7 NS per one)
N 4000 adds: static 24.3 dynamic 94.5 micro (6.1 / 23.6 NS per one)
N 5000 adds: static 36.7 dynamic 115.5 micro (7.3 / 23.1 NS per one)
N 6000 adds: static 37.7 dynamic 120.0 micro (6.3 / 20.0 NS per one)
N 7000 adds: static 42.9 dynamic 193.1 micro (6.1 / 27.6 NS per one)
N 8000 adds: static 45.8 dynamic 215.1 micro (5.7 / 26.9 NS per one)
N 9000 adds: static 51.0 dynamic 227.9 micro (5.7 / 25.3 NS per one)
N 10000 adds: static 52.6 dynamic 242.7 micro (5.3 / 24.3 NS per one)
N 11000 adds: static 57.8 dynamic 255.0 micro (5.3 / 23.2 NS per one)
N 12000 adds: static 63.1 dynamic 268.7 micro (5.3 / 22.4 NS per one)
N 13000 adds: static 69.8 dynamic 388.9 micro (5.4 / 29.9 NS per one)
N 14000 adds: static 70.0 dynamic 433.2 micro (5.0 / 30.9 NS per one)
N 15000 adds: static 78.0 dynamic 443.6 micro (5.2 / 29.6 NS per one)
N 16000 adds: static 80.3 dynamic 462.0 micro (5.0 / 28.9 NS per one)
N 17000 adds: static 84.4 dynamic 467.9 micro (5.0 / 27.5 NS per one)
N 18000 adds: static 87.8 dynamic 485.7 micro (4.9 / 27.0 NS per one)
N 19000 adds: static 92.5 dynamic 496.8 micro (4.9 / 26.1 NS per one)
N 20000 adds: static 98.5 dynamic 507.0 micro (4.9 / 25.3 NS per one)
N 21000 adds: static 102.4 dynamic 524.0 micro (4.9 / 25.0 NS per one)
N 22000 adds: static 105.1 dynamic 536.5 micro (4.8 / 24.4 NS per one)
N 23000 adds: static 111.5 dynamic 546.8 micro (4.8 / 23.8 NS per one)
N 24000 adds: static 115.2 dynamic 560.0 micro (4.8 / 23.3 NS per one)
N 25000 adds: static 119.8 dynamic 573.9 micro (4.8 / 23.0 NS per one)
N 26000 adds: static 124.3 dynamic 591.0 micro (4.8 / 22.7 NS per one)
N 27000 adds: static 134.4 dynamic 823.7 micro (5.0 / 30.5 NS per one)
N 28000 adds: static 156.2 dynamic 879.1 micro (5.6 / 31.4 NS per one)
N 29000 adds: static 169.5 dynamic 892.0 micro (5.8 / 30.8 NS per one)
N 30000 adds: static 173.3 dynamic 900.7 micro (5.8 / 30.0 NS per one)
N 31000 adds: static 179.5 dynamic 915.0 micro (5.8 / 29.5 NS per one)
N 32000 adds: static 175.6 dynamic 930.6 micro (5.5 / 29.1 NS per one)
N 33000 adds: static 191.8 dynamic 910.2 micro (5.8 / 27.6 NS per one)
N 34000 adds: static 217.9 dynamic 985.1 micro (6.4 / 29.0 NS per one)
N 35000 adds: static 215.8 dynamic 967.0 micro (6.2 / 27.6 NS per one)
N 36000 adds: static 219.6 dynamic 983.2 micro (6.1 / 27.3 NS per one)
N 37000 adds: static 217.7 dynamic 994.9 micro (5.9 / 26.9 NS per one)
N 38000 adds: static 230.5 dynamic 1024.2 micro (6.1 / 27.0 NS per one)
N 39000 adds: static 271.8 dynamic 1022.8 micro (7.0 / 26.2 NS per one)
N 40000 adds: static 255.1 dynamic 1039.7 micro (6.4 / 26.0 NS per one)
N 41000 adds: static 260.6 dynamic 1069.2 micro (6.4 / 26.1 NS per one)
N 42000 adds: static 315.1 dynamic 1054.7 micro (7.5 / 25.1 NS per one)
N 43000 adds: static 291.4 dynamic 1070.5 micro (6.8 / 24.9 NS per one)
N 44000 adds: static 290.8 dynamic 1083.9 micro (6.6 / 24.6 NS per one)
N 45000 adds: static 309.3 dynamic 1101.8 micro (6.9 / 24.5 NS per one)
N 46000 adds: static 318.3 dynamic 1102.6 micro (6.9 / 24.0 NS per one)
N 47000 adds: static 309.3 dynamic 1124.6 micro (6.6 / 23.9 NS per one)
N 48000 adds: static 325.9 dynamic 1137.7 micro (6.8 / 23.7 NS per one)
N 49000 adds: static 362.4 dynamic 1144.8 micro (7.4 / 23.4 NS per one)
N 50000 adds: static 357.1 dynamic 1054.1 micro (7.1 / 21.1 NS per one)
N 51000 adds: static 234.5 dynamic 1089.1 micro (4.6 / 21.4 NS per one)
N 52000 adds: static 247.6 dynamic 2612.8 micro (4.8 / 50.2 NS per one)
N 53000 adds: static 254.8 dynamic 1669.1 micro (4.8 / 31.5 NS per one)
N 54000 adds: static 273.9 dynamic 1791.0 micro (5.1 / 33.2 NS per one)
N 55000 adds: static 316.9 dynamic 3140.4 micro (5.8 / 57.1 NS per one)
N 56000 adds: static 296.3 dynamic 1884.0 micro (5.3 / 33.6 NS per one)
N 57000 adds: static 325.8 dynamic 1849.4 micro (5.7 / 32.4 NS per one)
N 58000 adds: static 372.7 dynamic 2062.6 micro (6.4 / 35.6 NS per one)
N 59000 adds: static 341.5 dynamic 2215.7 micro (5.8 / 37.6 NS per one)
N 60000 adds: static 497.0 dynamic 2490.9 micro (8.3 / 41.5 NS per one)
N 61000 adds: static 511.2 dynamic 2285.5 micro (8.4 / 37.5 NS per one)
N 62000 adds: static 526.4 dynamic 2083.6 micro (8.5 / 33.6 NS per one)
N 63000 adds: static 313.2 dynamic 1817.0 micro (5.0 / 28.8 NS per one)
N 64000 adds: static 531.5 dynamic 2183.0 micro (8.3 / 34.1 NS per one)
N 65000 adds: static 311.8 dynamic 2191.7 micro (4.8 / 33.7 NS per one)
N 66000 adds: static 665.5 dynamic 1962.9 micro (10.1 / 29.7 NS per one)
N 67000 adds: static 648.9 dynamic 1986.4 micro (9.7 / 29.6 NS per one)
N 68000 adds: static 638.1 dynamic 1951.4 micro (9.4 / 28.7 NS per one)
N 69000 adds: static 639.8 dynamic 1986.4 micro (9.3 / 28.8 NS per one)
N 70000 adds: static 639.5 dynamic 1909.1 micro (9.1 / 27.3 NS per one)
N 71000 adds: static 648.7 dynamic 2040.6 micro (9.1 / 28.7 NS per one)
N 72000 adds: static 694.5 dynamic 1890.6 micro (9.6 / 26.3 NS per one)
N 73000 adds: static 379.1 dynamic 2222.7 micro (5.2 / 30.4 NS per one)
N 74000 adds: static 390.4 dynamic 2313.9 micro (5.3 / 31.3 NS per one)
N 75000 adds: static 753.2 dynamic 2134.3 micro (10.0 / 28.5 NS per one)
N 76000 adds: static 677.3 dynamic 2075.2 micro (8.9 / 27.3 NS per one)
N 77000 adds: static 683.4 dynamic 2132.5 micro (8.9 / 27.7 NS per one)
N 78000 adds: static 698.4 dynamic 2126.0 micro (9.0 / 27.3 NS per one)
N 79000 adds: static 664.7 dynamic 1997.1 micro (8.4 / 25.3 NS per one)
N 80000 adds: static 420.3 dynamic 2431.2 micro (5.3 / 30.4 NS per one)
N 81000 adds: static 851.4 dynamic 2015.1 micro (10.5 / 24.9 NS per one)
N 82000 adds: static 432.5 dynamic 2076.0 micro (5.3 / 25.3 NS per one)
N 83000 adds: static 862.8 dynamic 3378.8 micro (10.4 / 40.7 NS per one)
N 84000 adds: static 515.8 dynamic 2251.3 micro (6.1 / 26.8 NS per one)
N 85000 adds: static 522.7 dynamic 2481.8 micro (6.1 / 29.2 NS per one)
N 86000 adds: static 536.9 dynamic 2464.0 micro (6.2 / 28.7 NS per one)
N 87000 adds: static 535.9 dynamic 2786.3 micro (6.2 / 32.0 NS per one)
N 88000 adds: static 534.9 dynamic 2383.4 micro (6.1 / 27.1 NS per one)
N 89000 adds: static 563.2 dynamic 2382.4 micro (6.3 / 26.8 NS per one)
N 90000 adds: static 571.7 dynamic 2508.2 micro (6.4 / 27.9 NS per one)
N 91000 adds: static 583.6 dynamic 3480.7 micro (6.4 / 38.2 NS per one)
N 92000 adds: static 1366.6 dynamic 5205.4 micro (14.9 / 56.6 NS per one)
N 93000 adds: static 1294.3 dynamic 5467.1 micro (13.9 / 58.8 NS per one)
N 94000 adds: static 1183.4 dynamic 4814.9 micro (12.6 / 51.2 NS per one)
N 95000 adds: static 989.3 dynamic 2293.0 micro (10.4 / 24.1 NS per one)
N 96000 adds: static 532.8 dynamic 2847.9 micro (5.5 / 29.7 NS per one)
N 97000 adds: static 875.8 dynamic 2340.6 micro (9.0 / 24.1 NS per one)
N 98000 adds: static 575.1 dynamic 2487.5 micro (5.9 / 25.4 NS per one)
N 99000 adds: static 638.7 dynamic 2663.4 micro (6.5 / 26.9 NS per one)
N 100000 adds: static 649.4 dynamic 2873.3 micro (6.5 / 28.7 NS per one)

> N 100000 adds: static 649.4 dynamic 2873.3 micro (6.5 / 28.7 NS per one)

this was on this resizable/growin array (in static is 7 ns on 16B record, and growin is 30ns iits imo standable) the fact is in very many casses it dont matter esp the adding and deleting are not time critical normally (in many cases they are in fact once at game start or something), or on level loading ...)..and acces itself is more close though probably heap-arrys are little slower than fully static ones

the second part would be on this "insert remove" array.. i think it should be done via .enabled flag, but there are details how to do it precisely... usually i was doing this on static array where i was rolling the iterator (cursor) always forward until i found not enabled record then pasted it here - this is always forward until found atc, removing was just putting .enabled to false

hovever i recently think if not to chamge that.. becouse sometimes you use arrays for square complex loops (for collisions for example) and then if you use such arrays you must iterate for whole static reserve in both arrays ... it is maybe not good ..those iterations are empty byt as its sqwuare better not do that imo

one alternative is to count deletions by some holes_count++(which is cheap) and if this hoels_count is more than zero just loop for arary ind insert there and holes_count--,
also function for 'packing' can be provided just to packrecords inmeantime by coping them from higher end into holes ...later i will maybe test it

niedziela, 6 sierpnia 2023 o 22:07:59 UTC+2 fir napisał(a):
> > N 100000 adds: static 649.4 dynamic 2873.3 micro (6.5 / 28.7 NS per one)
> this was on this resizable/growin array (in static is 7 ns on 16B record, and growin is 30ns iits imo standable) the fact is in very many casses it dont matter esp the adding and deleting are not time critical normally (in many cases they are in fact once at game start or something), or on level loading ...)..and acces itself is more close though probably heap-arrys are little slower than fully static ones
>
> the second part would be on this "insert remove" array.. i think it should be done via .enabled flag, but there are details how to do it precisely.... usually i was doing this on static array where i was rolling the iterator (cursor) always forward until i found not enabled record then pasted it here - this is always forward until found atc, removing was just putting .enabled to false
>
> hovever i recently think if not to chamge that.. becouse sometimes you use arrays for square complex loops (for collisions for example) and then if you use such arrays you must iterate for whole static reserve in both arrays .. it is maybe not good ..those iterations are empty byt as its sqwuare better not do that imo
>
> one alternative is to count deletions by some holes_count++(which is cheap) and if this hoels_count is more than zero just loop for arary ind insert there and holes_count--,
> also function for 'packing' can be provided just to packrecords inmeantime by coping them from higher end into holes ...later i will maybe test it

from the above after soem slight thinking i decided the defragmentation is probably better
(than find+insert)

i made same test: added 1000 logical circles randomly then dleted 300 randomly
(some delete hits could hit already deleted so physically less than 300)
and tested the collisions before and after fragmentation to check if its gives some
noticable improvement or its slight

it showed

adds time 83.7 micro
deletions time 7.6 micro (holes 300)
collisions 202 time 20.6 milis
defragmentation time 5.5 micro (size 739) (defrags 261)
collisions 378 time 14.7 milis

from 20 to 15 millis so the improvement is quite big in thsi case

code for this

///////////////DYNAMIC ARRAY/////////////////////////////

Agent* agent = NULL; int agent_size = 0; int agent_last_reallockd = 0; int agent_holes = 0;

int AddAgent(float x,float y, float r)
{ if(++agent_size > agent_last_reallockd) agent = (Agent*) realloc(agent, (agent_last_reallockd = 2*agent_size+100)*sizeof(Agent) );
agent[agent_size-1] = {1,x,y,r};
} void DeleteAgent(int i) { agent[i].enabled =0; agent_holes++;}

int defrags_done = 0;

void DefragmentAgentArray()
{ defrags_done = 0;

if(agent_holes>0)
for(int i=0; i<agent_size; i++)
if(!agent[i].enabled)
{
for(int k=agent_size; k>i; k--)
if(agent[k].enabled) break; else defrags_done++, agent_size--;

defrags_done++; agent[i] = agent[--agent_size];
}

agent_holes=0;
} ////////////////
//////////////// TESTS /////////

void AddAgentsResizableArray(int n) { for(int i=0; i<n;i++) AddAgent(rand2(-1000,1000),rand2(-1000,1000),10);}
void DeleteRandomSomeAgents(int n) { for(int i=0; i<n;i++) DeleteAgent(rand2(0,agent_size-1)) ;}

void TestDynamicArray()
{ float t;

TakeDeltaTimeNS(1); AddAgentsResizableArray(1000); t = TakeDeltaTimeNS(1);
printf("\n adds time %.1f micro ", t/1000 );

TakeDeltaTimeNS(1); DeleteRandomSomeAgents(300); t = TakeDeltaTimeNS(1);
printf("\n deletions time %.1f micro (holes %d) ", t/1000, agent_holes );

int collisions = 0;

TakeDeltaTimeNS(1);

for(int j=0; j<agent_size; j++)
{
if(!agent[j].enabled) continue;

for(int i=0; i<agent_size; i++)
{
if(!agent[i].enabled) continue;
if(i==j) continue;

float dx = agent[j].x - agent[i].x;
float dy = agent[j].y - agent[i].y;

float dist = sqrt(dx*dx+dy*dy);

if(dist<agent[i].r+agent[j].r) collisions++;
}
}

t = TakeDeltaTimeNS(1);

printf("\n collisions %d time %.1f milis ", collisions, t/1000/1000 );

TakeDeltaTimeNS(1); DefragmentAgentArray(); t = TakeDeltaTimeNS(1);
printf("\n defragmentation time %.1f micro (size %d) (defrags %d) ", t/1000, agent_size, defrags_done );

TakeDeltaTimeNS(1);

for(int j=0; j<agent_size; j++)
{
if(!agent[j].enabled) continue;

for(int i=0; i<agent_size; i++)
{
if(!agent[i].enabled) continue;
if(i==j) continue;

float dx = agent[j].x - agent[i].x;
float dy = agent[j].y - agent[i].y;

float dist = sqrt(dx*dx+dy*dy);

if(dist<agent[i].r+agent[j].r) collisions++;
}
}

t = TakeDeltaTimeNS(1);
printf("\n collisions %d time %.1f milis ", collisions, t/1000/1000 );

}

poniedziałek, 7 sierpnia 2023 o 06:56:17 UTC+2 fir napisał(a):
> for(int k=agent_size; k>i; k--)
should be for(int k=agent_size-1; k>i; k--)

and collosions =0; before second test..the results close though (20 ms/16 ms)

note btw how people are weird thet are able to discuss "standard insanity" in hundreds and thousands of post and this totally interesting and important topic on dynamic arrays is not discussed (except me doing that)