Fixing memory usage when writting animations

The options -b and -B specify a buffer size for images waiting to we writtent
on disk

gte/__main__.py

 parser_gen.add_argument('--threads', '-t', type=int, metavar='N',
                         default=os.cpu_count()-1,
                         help="Animation writting threads")
+parser_gen.add_argument('--buffer-min', '-b', type=int, metavar='N',
+                        default=10,
+                        help="Start populating animation buffer when this \
+amount of images are in the buffer")
+parser_gen.add_argument('--buffer-max', '-B', type=int, metavar='N',
+                        default=100,
+                        help="Start a buffer flush when this amount of images \
+are in the buffer")
 
 args = parser.parse_args()
 
             im.save(fname)
             logger.debug('Image %s saved in %.3fs' % (fname, 
                                                       time.time() - st1))
+            del(im)
 
         write_pool = Pool(args.threads)
         async_res = []
         img_count = 0
+        img_total = args.steps if args.anim_div <=1 else args.steps / (args.anim_div - 1)
     w = World(args.world_height, args.world_width, gray=args.gray)
     prog = rpnlib.RpnExpr.from_string(args.prog)
     turmits = [LivingTurmit(world=w, prog=prog, diag=not args.no_diagonals)
     start = time.time()
     for step in range(args.steps):
         if step % 512 == 1:
-            msg = 'Step %d/%d %dus/step fractdim=%.3f'
+            msg = 'Step %d/%d avg: %dus/step fractdim=%.3f'
             msg %= (step, args.steps,
                     ((time.time() - start)*1000000)//step//len(turmits),
                     w.fractdim())
             fname = os.path.join(args.output_dir, fname)
             im = Image.fromarray(np.uint8(w._val))
             async_res.append(write_pool.apply_async(save_pool, (im, fname)))
-            while async_res[0].ready():
-                async_res[0].get()
-                async_res.pop(0)
+            if len(async_res) > args.buffer_max:
+                logger.debug('Flushing animation on disk to empty RAM')
+                while len(async_res) > args.buffer_min:
+                    while async_res[0].ready():
+                        async_res[0].get()
+                        async_res.pop(0)
+                msg = '%d/%d images written at avg %.0f img/s ETL : %ds'
+                img_prog = img_count - args.buffer_min
+                img_pers = img_prog/((time.time() - start))
+                etl = (img_total - img_prog) // img_pers
+                msg %= (img_prog, img_total, img_pers, etl)
+                logger.info(msg)
     
     if args.output_dir is not None:
-        while async_res[0].ready():
+        while len(async_res) and async_res[0].ready():
             async_res[0].get()
-            sync_res.pop(0)
+            async_res.pop(0)
         write_pool.close()
         logger.info('Waiting for animation to be written on disk')
         img_st1 = None