Berry script consuming objects and increasing LoadAvg

[martin072]

I am finding my way into Berry Scripting, and I am using a script that makes a driver and uses the 'every_1s' loop to check an analog input, and according to that value play an animation on a ws2812 ring (used the berry example script) and also put some info on the Web UI.

What I noticed is that when running the script, the load average goes from '19' to '99' and stays around there, with about 234 berry objects. But then when the animation starts, it keeps on increasing the Berry Objects, and the load avg gets higher and higher. At a certain point the module looses its wifi connection, and only a reset will get it back online.

Not sure if it is some bad coding, but inside the 1_sec loop I only check the analog every 10sec. and change color and restart the animation as follows;

def set_ring(state, color, speed, brightness, tail)
        if state == "OFF"
            if self.ring self.ring.stop() end
            self.strip.clear()
        elif state == "ON"
            if self.ring self.ring.stop() end
            self.strip.clear()
            self.ring = nil
            self.ring = led_trail(self.strip, speed, color, tail)
            self.ring.set_bri(brightness)
            self.ring.start()
        end
  end

Anything I am doing incorrect?

[sfromis]

The single function of your code is not enough to form an idea of what may be happening or not. What's bad depends on the flow of the code all the way. Unsurprisingly, a memory leak with berry object count only going up is pretty bad, and indeed likely to cause major failure, but debugging of that depends on more than the function you posted, and how it is even used.

You should not read a lot into whatever you get in "load average", as this is not at all an average load 😀

[martin072]

Ok so I will try to give it a go, see if I can isolate the part where the apparent memory leak occurs if even possible. As mentioned. Running the script and not using the led animation seem to leave the object count stable.

Any other ways to do a proper debugging in berry?

[sfromis]

No, not if you mean a debugger with breakpoints and so on. If your posted function was workable on it's own, that could be a good starting point for debugging.....

One avenue for debugging a object leak could be to check tasmota.get_free_heap() (and maybe tasmota.memory()) (like printing it) at relevant points.

[martin072]

Ok, so it's eating up the heap, and caused by the function I posted in the first post.
Achievement is to restart the ring with a different color and speed.

so by doing:

self.ring = nil
self.ring = led_trail(self.strip, speed, color, tail)

I was assuming the object is destroyed, and re-created again. this apparently doesn't go well and eats up the heap. See below

"Berry":{"HeapUsed":19,"Objects":235}

13:51:52.853 Mem:  {'heap_free': 92, 'program_free': 929, 'program': 1950, 'stack_low': 3.69141, 'iram_free': 28, 'frag': 14, 'flash': 4096, 'stack_size': 8, 'flash_real': 4096}
13:52:02.862 Mem:  {'heap_free': 87, 'program_free': 929, 'program': 1950, 'stack_low': 3.69141, 'iram_free': 28, 'frag': 9, 'flash': 4096, 'stack_size': 8, 'flash_real': 4096}
13:52:12.860 Mem:  {'heap_free': 82, 'program_free': 929, 'program': 1950, 'stack_low': 3.69141, 'iram_free': 28, 'frag': 3, 'flash': 4096, 'stack_size': 8, 'flash_real': 4096}
13:52:22.867 Mem:  {'heap_free': 87, 'program_free': 929, 'program': 1950, 'stack_low': 3.69141, 'iram_free': 28, 'frag': 10, 'flash': 4096, 'stack_size': 8, 'flash_real': 4096}
13:52:32.851 Mem:  {'heap_free': 84, 'program_free': 929, 'program': 1950, 'stack_low': 3.69141, 'iram_free': 28, 'frag': 5, 'flash': 4096, 'stack_size': 8, 'flash_real': 4096}
13:52:42.866 Mem:  {'heap_free': 80, 'program_free': 929, 'program': 1950, 'stack_low': 3.69141, 'iram_free': 28, 'frag': 6, 'flash': 4096, 'stack_size': 8, 'flash_real': 4096}

"Berry":{"HeapUsed":23,"Objects":307}

And this is the led_trail animation class:

class led_trail : Leds_animator
    var cur_offset     
    var cur_color
    var tail

    def init(strip, duration, color, tail)
      super(self).init(strip)
      self.cur_offset = 0
      self.cur_color = color
      if !tail 
        self.tail = 4
      else
        self.tail = tail
      end
      # add an animator to change `self.cur_offset` to each value of the palette
      self.add_anim(animate.rotate(def(v) self.cur_offset = v end, 0, 23, int(duration * 1000)))  
    end
  
    def animate()
      var i = 0
      while i < self.pixel_count    # doing a loop rather than a `for` prevents from allocating a new object
        var col = self.cur_color
        #print ("offset :", self.cur_offset)
        if ((self.cur_offset + i) % 24)  >= self.tail
            col = 0x000000
        end
        self.strip.set_pixel_color(i, col, self.bri)   # simulate the method call without GETMET
        i += 1
      end
      self.strip.show()
    end
end

[sfromis]

What I meant by debugging was more than to demonstrate that the numbers are showing that a leak happens, but where/when. At relevant points for getting closer to that.

[martin072]

Well as mentioned, if I run the script without altering the animation, it's fine, hence the part where I change the animation in the berry script causes the leak to happen. Why it does that I don't know, first time Berry user, have some programming skills, but I an definitely not a wizzkid 😉

So I am assuming that re-calling the animation class over and over causes it to happen. As mentioned, I just took the animation example from the Berry part of Tasmot's docs..

[s-hadinger]

The animation framework is in early alpha stage. I wouldn't rely too much on it right now, I haven't found the sweet spot to easily describe led animations. I'm open to ideas.

[martin072]

Ok, thanks.

it also seems a lack of knowledge from my part. I've changed the script slightly not to re-create the animation every time, and just adjust the colours. That seems to work, no more leaks. However I would stil like to change the speed of the animation.

So perhaps in a different manner;

How can you re-initialize the animator object with a different speed? the way I did it doesn't work apparently, as it causes the leaks.

[sfromis]

Well, you did not "just take" the animation sample, but you made it work, and then changed the code 😉 And still not posting the code for your test case to start and run.

Anyway, it sounds plausible with restarting the animation as a factor for missing cleanups. I see that the docs mentions a stop() method, and while I do not see this now, the docs does suggest that this need should be covered by the clear() method you use. However, running a small test, based on the minimally modified docs example (to make init work), revealed that calling the clear method neither stopped animation nor make the pixels go dark (only a small blink). The ongoing animation after clear() fits well with memory not being cleaned up. Are you seeing the clear() method doing anything useful to stop the running animation?

I hope that the code you did not post is not allocating a new strip (or Leds object) before calling set_ring next time?

[martin072]

No the strip is defined in the tasmota driver and only initialised there.
I also tried with clear(), stop() and remove(), but no change there, memory still not de-allocated.

But here you go

# AdcParam 6, 0, 4095, 0, 100 -> Mapping of ADC Input from 0-100% related to input
# No need for remapping in code

import json
import string
import light
import animate

class led_trail : Leds_animator
    var cur_offset     
    var cur_color
    var tail

    def init(strip, duration, color, tail)
      super(self).init(strip)
      self.cur_offset = 0
      self.cur_color = color
      if !tail 
        self.tail = 4
      else
        self.tail = tail
      end
      # add an animator to change `self.cur_offset` to each value of the palette
      # half of the led's so will make to spinning rings 180º offset
      self.add_anim(animate.rotate(def(v) self.cur_offset = v end, 0, 23, int(duration * 1000)))  
    end

  
    def animate()
      var i = 0
      while i < self.pixel_count    # doing a loop rather than a `for` prevents from allocating a new object
        var col = self.cur_color
        #print ("offset :", self.cur_offset)
        if ((self.cur_offset + i) % 24)  >= self.tail
            col = 0x000000
        end
        self.strip.set_pixel_color(i, col, self.bri)   # simulate the method call without GETMET
        i += 1
      end
      self.strip.show()
    end
end


class animateTest : Driver

    var strip
    var ring
    var sec
    var vin
    var pvin

    def init()
        tasmota.cmd("AdcParam 6, 0, 4095, 0, 100")
        self.strip = Leds(24, 15, Leds.WS2812_GRB)
        self.strip.clear()
        self.strip.show()
        self.set_ring("ON", 0xFDA600, 1.0, 50, 12)
        self.vin = 0
        self.sec = 0 
        self.pvin = 0
    end

 
    def airvent()
            
        var spd = self.fmap(self.vin,0,100,0.5,2.5)
        spd = 3 - spd
        if self.vin > 70
            if self.vin != self.pvin
                self.set_ring("ON", 0xff0000, spd, 50, 12)
                self.pvin = self.vin
            end
        elif self.vin > 50
            if self.vin != self.pvin
                self.set_ring("ON", 0xfaac02, spd, 50, 10)
                self.pvin = self.vin
            end
        elif self.vin > 30
            if self.vin != self.pvin
                self.set_ring("ON", 0x00ff00, spd, 50, 8)
                self.pvin = self.vin
            end
        else 
            if self.vin != self.pvin
                self.set_ring("ON", 0x0000ff, spd, 50, 4)
                self.pvin = self.vin
            end
        end

    end
    
    def every_second()
        # Read needed Sensor data
        if !self.airvent return nil end
        var sensors=json.load(tasmota.read_sensors())
        self.vin = sensors['ANALOG']['Range1']
        self.sec +=1
        if self.sec % 10 == 0
            self.airvent()
            self.sec = 0 
        end
    end

    def set_ring(state, color, speed, brightness, tail)
        if !tail 
            tail = 4
        end
        if state == "OFF"
            if self.ring 
                self.ring.stop()
                self.ring.clear()
                self.ring.remove()
                self.ring = nil
            end
            self.strip.clear()
        elif state == "ON"
            if self.ring 
                self.ring.stop()
                self.ring.clear()
                self.ring.remove()
                self.ring = nil
            end
            self.ring = led_trail(self.strip, speed, color, tail)
            self.ring.set_bri(brightness)
            self.ring.start()
        end
    end

    def set_ring_color(col,brightness)
        var i = 0
        self.strip.clear()
        while i < self.strip.pixel_count()   # doing a loop rather than a `for` prevents from allocating a new object
            self.strip.set_pixel_color(i, col, brightness)
            i +=1
        end
        self.strip.show()
    end

    def fmap(x, in_min, in_max, out_min, out_max)
        return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
    end

end


var t = animateTest()
tasmota.add_driver(t)

[martin072]

Did you manage to reproduce it with the above code?

One thing I thought about, since it is easy to change the colours and brightness without redefining the object, would it be possible to add the speed/duration to be configurable during run-time?

i.e

set_duration(bri:float) -> nil Sets the duration of the animation in seconds