[Helmut Wunder]

where in the github jungle labyrinth is the file which performs Kociemba’s algorithm?

[Helmut Wunder]

I’m actually curious if there is already Cubesolver code running on the EV3 which performs Kociemba’s algorithm autonomously, without using lookup tables etc?
E.g., is this what Jacek S’ code is doing?

• This reply was modified 8 years, 7 months ago by Helmut Wunder.

[Helmut Wunder]

thank you for your explanation, now I see clear 😎

– I took the best and the worst runs of 1-5, of either way –
just observed:
1 current value had to be corrected, i.e. (4) for matrices.

The HaWe Brickbench Benchmark comparison Tables now had been updated!
(some questions marks remaining for daisy chaining, raw BT and raw Wifi etc.
if you should encounter issues, mistakes or bugs: please feel free to report, inputs are highly appreciated!):

http://www.mindstormsforum.de/viewtopic.php?f=71&t=8095&p=64772#p64772

thank you Anders for your input and your participation !
Over all really a great job! 😎

[Helmut Wunder]

do I understand correctly:
AOT is precompiled,
and instead it would be like JIT for leJOS ?

so if it was precompiled – there shoudn’t be any remarkable runtime differences – correct ?

FTM, this would be the benchmarks from best to worst case (either if AOT or JIT, and by either run:

no. new min/max (old min/max)
0     1 -  16   (  1 -  15)
1    25 -  67   ( 26 -  35)
2   227 - 245   (155^ -212^) // renewed
3    12 -  18   ( 13 -  19)
4    40 -  98   ( 35 - 229 )
5   150 - 176   (179 - 299)
6   219 - 333   (268 - 395)
7   158 - 302   (185 - 475)

would you say this is correct ?
(tbh, a printed list would be a little more clearly arranged for evalutaion than just photos 😎 )

[Helmut Wunder]

what is AOT and what is not-AOT ?
what is the common way ?

[Helmut Wunder]

ok – I’ll conclude:

no. new min/max (old 1st - 5th)
0     1 -   5   ( 15 - 1)
1    25 -  67   ( 35 - 26)
2   227 - 245   (212^- 155^) // renewed
3    12 -  18   ( 19 - 13)
4    40 -  98   (229 - 35 )
5   150 - 176   (299 - 179)
6   219 - 333   (395 - 268)
7   158 - 302   (475 - 185)

would this be correct ? (I#m a little confused, admittedly 😉 )

[Helmut Wunder]

maybe pimped by a BBB ? 😛

[Helmut Wunder]

thank you very much for your input!

to my surprise these new data differ a lot from previous test results (range shown in braces for the 1st to the 5th run):
your new data by 1st run show more or less identical values which had been performed previously not until far later runs, partially even faster than already the gpp C results for native executables which is actually more than surprising (even considering that for gpp C the Lego VM is still running simultaneously) – so this is now a much better performance for the start than before :

no. new (old 1st - 5th)
0     1   ( 15 - 1)
1    25   ( 35 - 26)
2   233   (212^- 155^) // renewed
3    12   ( 19 - 13)
4    40   (229 - 35 )
5   150   (299 - 179)
6   219   (395 - 268)
7   158   (475 - 185)

are you using a different compiler than before? in case yes: which version?
for completion of the list I’m also very curious about how the values would be for e.g., the 3rd and the 5th run additionally!

Thank you for your efforts!
Helmut

[Helmut Wunder]

hey y’all,
what about a new test run ?

[Helmut Wunder]

just a typo about err:
err = Sollwert-Zielwert is wrong of course, it should have been
err = Sollwert-Istwert (= targetVal-currentVal)

[Helmut Wunder]

Dude, as I already wrote you in our German forum, you will …

1st of all need to stop the correct loop time which surely is different from 20 (ms) !
dt= currTime- saveTime;

2nd,
where do you calculate the error (err) – maybe I missed it?
then, what about this line:
integral = integral + (angle * dt);
???
the correct PID formulas are the following:

err = Sollwert-Zielwert
Integr = Integr + err
PWMpwr= (KP*err) + (KI*integr)*dt + (KD*(err-errorold))/dt;

and 3rd,
then you will finally surely need to tune (and fine-tune) your PID constants!

a hint for your PID regulation:
the loop propably will have to look something like the following:

loop:
dt= currTime- saveTime;
saveTime= currTime
err = Sollwert-Zielwert
Integr berechnen (Integr = Integr + err)
PWMpwr= (KP*err) + (KI*integr)*dt + (KD*(err-errorold))/dt;
errorold=err
PWMpwr auf Motoren anwenden
dann wieder loop von vorn!

[Helmut Wunder]

hi,
would please be someone so kind and test the new benchmark, after replacing the old float-Test
in this test program class
https://github.com/vladru/MonoBrickBench

by the new one?

     static void TestFloatMath() {
         double s = 3.141592;
         int y;

         for (y = 0; y < 1000; ++y) {
            s *= Math.Sqrt(s);     
            s = Math.Sin(s);
            s = Math.Exp(s);
            s *= s;              
         }
         //return s;
      }

[Helmut Wunder]

BTW,
how much non-volatile memory for code + stored data is available by Mono on the EV3?

As just a user reported, on the original Lego flash only 5M are free, same 5M non-volaitle memory are free for excutables compiled by gpp C and CSLite toolcahins – the rest is used for OS and VM.
If Mono is booting by a SD card (e.g. 4GB or 16GB): how much memory is free for variables or program code over all at most?

BTW 2:
the fixed leJOS benchmark has been published, but for the fixed adapted benchmarks the runtimes haven’t changed so much.
http://www.mindstormsforum.de/viewtopic.php?f=71&t=8095#p64772

Updated Mono benchmarks would be very much appreciated though! 🙂

BTW 3:
Another new programming language has appeared on the horizon: EV3-Basic, made just for kids and beginners, targeting the Lego lms2012 VM by MS Small Basic and homebrewed DLLs for autonomous and remote programs:

https://github.com/c0pperdragon/EV3Basic
http://www.mindstormsforum.de/viewtopic.php?f=25&t=8529#p66211

share and enjoy!

• This reply was modified 9 years, 2 months ago by Helmut Wunder.

[Helmut Wunder]

unfortunately the NAN bug still was not fixed yet, the sub test has been fixed again – now all intermediate values have been controlled and verified, no NANs any more. This is the corrected current sub test code for float and transcendental functions:

static void TestFloatMath() {
         double s = 3.141592;
         int y;

         for (y = 0; y < 1000; ++y) {
            s *= Math.Sqrt(s);     
            s = Math.Sin(s);
            s = Math.Exp(s);
            s *= s;              
         }
         //return s;
      }

[Helmut Wunder]

hi,
a recent note:
a bug has been reported to the float_math benchmark where NANs have been generated, so an additional line
s=s*s
has been added at the end.

so the updated procedure would be supposed to look as follows:

// updated sub-test for HaWeBench 1.9.0 C#/Mono

static void TestFloatMath() {
         double s = 3.141592;
         int y;

         for (y = 0; y < 5000; ++y) {
            s *= Math.Sqrt(s);   // <<<<< no issue any longer      
            s = Math.Sin(s);
            s *= Math.Cos(10.5 * s);
            s = Math.Sqrt(s);   //  <<< hopefully no additional issue now :-/ 
            s = Math.Exp(s);
            s *= s;             //  <<<<<<<<<<<<< new line !!!!!!!!!!!!!!!!!
         }
         //return s;
      }

On some platforms the new benchmarks (1.0.9) already have been updated by minor changes, RobotC, C#, and leJOS still pending yet.

thanks for your interest,
kind regards,
Helmut

[Author]

Posts