Question

So, I am working on a game in android, and I was checking out the heap and allocations to see if there was anything going wrong with memory and what not. When I got to the heap, it told me that it had allocated 33 mb for my game, and 31 mb was allocated to 1-byte array types. I went through trying to figure out why this was as large as it was, but I had no luck, and no idea what to look for even. Does anyone have any ideas? Thanks in advance! Let me know if you need any more info.

Will

Edit:

I wasn’t exactly clear on what was happening, sorry, was late when I posted this.

Basically I made a simple multitouch checker, code below, and when I ran it, I decided to check the heap. As I said above it was extremely large for what I was doing, just getting points and sticking a circle on it using draw

    public void onDraw(Canvas c)
    {
        c.drawColor(Color.BLACK);
        Point[] touchPlacesHolder = touchPlaces;
        for(int i = 0; i < touchPlacesHolder.length; i++)
        {
            c.drawCircle(touchPlacesHolder[i].x, touchPlacesHolder[i].y, 100, paint);
        }
    }

    public boolean onTouchEvent(MotionEvent event){
        touchPlaces = new Point[event.getPointerCount()];
        for (int i = 0; i < event.getPointerCount(); i++) 
        {
            touchPlaces[i] = new Point((int) event.getX(i), (int) event.getY(i));
        }
        return true;
    }

I am running this activity by linking it to a button on another via intent, the code is below. I am not sure if it has anything to do with the way I linked the 2 or not, maybe I caused a memory leak there.

public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    final Window win = getWindow();
    win.setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN); 
    requestWindowFeature(Window.FEATURE_NO_TITLE);
    setContentView(R.layout.main);

    final Button newGame = (Button) findViewById(R.id.new_game_button);
    newGame.setOnClickListener(new OnClickListener() {
        public void onClick(View v) {
            // Perform action on clicks
            Intent intent = new Intent(v.getContext(), Platformer.class);
            startActivity(intent);
        }
    });
    final Button levelEditor = (Button) findViewById(R.id.level_editor);
    levelEditor.setOnClickListener(new OnClickListener() {
        public void onClick(View v) {
            Intent intent = new Intent(v.getContext(), LevelEditor.class);
            startActivity(intent);
        }
    });
}

As you can see, I have another activity attached to the buttons in the second bit of code I showed, but I figured I would ask about the simpler example because they are both using the same amount of memory, even though one is using bitmaps and the other isn’t.

So, basically my question is, why would something as simple as this require such a large heap, and why would it use so much of it when something much more complex like cut the rope is about half the size. Thanks!

Edit again:

I just changed the manifest to start with the simplest one and left the main menu and the other activity out. The multitouch tester had about 12 mbs used of its 13 mb heap. I did the same thing for the menu and it had about 25 mb allocated and was using most of it, and the other class I didn’t show used about 25 as well.

So, I’m guessing the extra memory being used it from it holding the menu in memory, but I am not sure why it is using so much memory for the menu in the first place. Any idea how to fix that or fix the way it is holding it in memory?

Answer 1

possible optimizations for both speed and memory:

1.how about using a fixed size array of max touch events and update it instead of creating a new one every time ? it’s a single thread that handle both so there should not be anything to worry about it .

2.invalidate only the areas that should be updated. this could improve speed.

3.update the touch events only before you know you wish to update .

4.not sure what is the game , but you can use a fixed size bitmap and write to it instead of saving the touch events.

5.since it’s a game , most of the memory is probably used for images ,sounds and videos . try to check if that’s a problem. since the classes that you’ve checked are 1-byte arrays , it might be the case of images. for more information on loading heavy resources, check :
http://developer.android.com/training/displaying-bitmaps/index.html

having a large heap size might indicate that you are creating a lot of small objects or a few large objects in a short time , since the gc take some time till it does something.