Capacity of MC on VA-HR

It might be nice to have this, but it's not currently there.

Might be nice???
Boy, you ain't kidding!:mad:
When there is a) an undefined limit (some say 256, but it's clearly more than that) and b) no way to monitor the usage and c) I'm planning to build a very large app, I can see a lot of tears ahead.:(

It would be nice (I believe it was said 256 on some devices, but could be 512 on the va-hr, as apps can be much larger with more memory on a va-hr vs a 1.x device).

Part of it, is that you really want to design your data so you don't hit the max or come close, and that's things like not using multi-dimension arrays (your code for just the array would actually be 501 arrays ("an array of arrays"), where you could have 1 array with the same data, and just use the [i,j] as an index to to that single array.

It's not that hard to write large, complex apps with lots of data, if you use the correct data structure.

Yes, I clearly hear the mantra about multi-dimensional arrays, but as you suggested, my problem with arrays probably isn't the memory usage, but the object usage.

I have 3,000 lines of javascript and 30Kb of compiled C in my app to port from pebble so what I'm trying to do in this evaluation phase is to understand just what the limits are and how to monitor them before I get part way through the project and either hit the wall or have to re-work my code.

Obviously, staying away from the limits is good advice, but that can only be achieved once the limits are well understood.

This is a hack, but you should be able to check the current object count with the following code.

// tricky function to get the current number of objects
function getNumberOfObjects() {

var obj = new Lang.Object();

// `s' is "Obj: 123"
var s = obj.toString();

// strip off "Obj: "
s = s.substring(5, s.length());

// now we have the object number
return s.toNumber();
}


If you want to discover the maximum object count, this seemed to work just fine...

using Toybox.Application as App;
using Toybox.Lang as Lang;
using Toybox.System as Sys;
using Toybox.WatchUi as Ui;

class XView extends Ui.View
{
function initialize() {
View.initialize();
}
}

class X
{
hidden var _M_self;

function initialize() {
// reference ourselves. this forces a leak of self.
_M_self = self;
}
}

class XApp extends App.AppBase
{
function initialize() {
AppBase.initialize();
}

function getInitialView() {
return [ new XView() ];
}

hidden var _M_timer;

function onStart(params) {
_M_timer = new Timer.Timer();
_M_timer.start(self.method(:onTimer), 25, true);
}

function onStop(params) {
_M_timer.stop();
_M_timer = null;
}

function onTimer() {
var x = new X();

// if you want to run this on a device, I recommend doing much less frequently
Sys.println(x);
}
}


On the simulator the output is...

Device Version 0.1.0
Device id 1 name "A garmin device"
Shell Version 0.1.0
Timer interval is too small. It has been set to the minimum supported value.
Obj: 20
...
Obj: 500
Obj: 501
Obj: 502
Obj: 503
Obj: 504
Obj: 505
Obj: 506
Obj: 507
Obj: 508
Obj: 509
Failed invoking <symbol>
Too Many Objects Error
in println (D:\jenkins\workspace\Tech-CIQ-Win-Rel\mbsimulator\submodules\technology\monkeybrains\virtual-machine\api\System.mb:216)
in onTimer (C:\Users\Travis\workspace\X\source\XApp.mc:47)
Failed invoking <symbol>
Error in timer callback
Connection Finished
Closing shell and port


Brilliant, thanks.
I can now start to manage my object count and even see the GC kick in every 60 seconds to take out the trash.

I guess there's no way to programmatically release an object (the one you create in getNumberOfObjects) is there?
[EDIT]
Ah, it looks like the objects created in a function are released when the function completes.

But something else is happening that I don't understand.
I have let my app run for 20 mins and captured the object count output from getNumberOfObjects() every second, charted the results and annotated the image attached.

The GC is still kicking in each minute, bringing the object count down to a MIN of around 100 and then it climbs up to a MAX of around 400, but as time marches on, the trace of object count becomes increasingly "noisy" till at around 20 minutes it's jumping all over the place, going from the MIN to the MAX in a couple of seconds and then back.
Since I'm only at the start of my code migration, I need to get a better handle on what's happening here.

I should add that the code is simply processing the simulated GPS data doing some manipulation on the data received in the last 60 seconds and displaying the data. The processing does not get more intense with time. I maintain an array of 60 seconds of data, pushing the old data down, losing the oldest record and pushing the new data on the top. The single dimension array remains a fixed size (60 data records of 10 properties = 600 rows).

After 50 minutes, the chart looks like this:


After 90 mins it's going from MIN to MAX in a second:
getNumberOfObjects,297
getNumberOfObjects,97
getNumberOfObjects,407
getNumberOfObjects,394

I suspect something else is at work. Here, after nearly two hours of running, the number is becoming quite random, increasing and decreasing by varying amounts every second:
getNumberOfObjects,153
getNumberOfObjects,395
getNumberOfObjects,155
getNumberOfObjects,129
getNumberOfObjects,344
getNumberOfObjects,294
getNumberOfObjects,248
getNumberOfObjects,376
getNumberOfObjects,292
getNumberOfObjects,207


Could this be due to the object number not actually being incremented on each instantiation but by the object number generator re-using object numbers released during the GC?
This might mean that the object number generated by new Lang.Object() isn't in fact the number of objects, but the first one of the free object numbers available?

This is real compiler archaeology ... wouldn't it be nice if the guys who look after the compiler could explain it to us?

Travis - interesting! I wouldn't have thought of using the object number!

RaceQs - What may be happening with the noise, is that an object is being freed that's below the max, so when you run Travis' code, it sees a lower object number than max. If you were using 300 objects, and #150 is freed, you'll get the number 150, which isn't really the count used at that time. Same with the drop back to the min. It could just be you're seeing a really low object number. Garbage collection likely would only be used for memory (make free memory contiguous, etc), where with objects, GC probably isn't involved (assuming a fixed number of objects that are the same size, all you really need is a list of those available, and no reason to GC them.)

What you may want to do is use travis' function to track the peak objects used, as current could be implicated when objects are returned.

Yes, Jim, you're right, GC isn't operating on the objects. I was blindsided by the 60-second cycle in the sawtooth chart.

When I reduce the number of data points in my array, from 60 to, say, 40, guess what? The sawtooth period drops to 40 seconds.
I don't understand that.
What I don't understand, though, is why the object count (or object index) climbs initially. Isn't an array a single object?

for (i = rows-2; i>=0; i--){ // move them all down one and lose the last
for (j =0; j< cols; j++){
track[ j*rows + i +1] = track[ j*rows + i];
}
}

track[0*rows ] = timeSecs;
track[1*rows ] = lat;
track[2*rows ] = lon;
track[3*rows ] = SOG;
track[4*rows ] = COG;
track[5*rows ] = TWD;
track[6*rows ] = DRLat;
track[7*rows ] = DRLon;


Each second I'm populating the array with eight values and initially, the object count increases by 4.
I wonder why?

I hadn't thought about it, but Jim is exactly right. Object numbers are recycled. The function above simply returns an unused object id, not the object count. If you aren't allocating and deallocating objects (you claim that you have a fixed array of data), then I don't really see how the object count should be a problem after initialization.

Do you have some code I can look at?

Travis