nv-buf-mem-mgmt

• simple buffer management util
• only index without real-buffer

install

• npm install nv-buf-mem-mgmt

splitted

usage

  const creat   = require("nv-buf-mem-mgmt").sync;
      //OR   
      //    const creat   = require("nv-buf-mem-mgmt").async;
      //.async API is same AS .sync,  JUST the defrag_callback CAN  BE a async-function


  var mem_mgmt = creat(
       mem_start_from   = 0; 
       mem_end_to       = 2**24, 
       defrag_callback  =(                                        
            m:Array<[
                [old_start_index, old_end_index],
                [new_start_index, new_end_index]
           ]>
      )=> Any
 ); 


      /*
            the defrag_callback  IS used to call REAL-BUFFER defrag:
                for example:
                   IF  a buffer of size32:     
                       0-5 10-25        is allocated;
                         5-10 25-32    total 5+7 = 12  is lefted, but the continuous size is 5,7
                         IF you call  .alloc(11):
                             11>5  11>7   BUT  11 <12
                             SO,  the .defrag  will BE auto-called, which will return a 【M】 :
                                  [ 
                                      [[5, 10] -> [0,5]  ]  
                                      [[10,25] -> [5,20] ]
                                  ]  
                            the .defrag_callback(【M】) => {
                                  you should do corresponding action on REAL-BUFFER, something like(based on what real buffer you use):
                                      let old = copy(REAL-BUFFER, 5,10)
                                      set(REAL-BUFFER,0,5, old);
                                      old = copy(REAL-BUFFER, 10,25)
                                      set(REAL-BUFFER,5,20, old);   
                                      .....                                        
                            } 
                           
              
      */

example

	var mem_mgmt = creat(0,32,(m)=>{console.dir(m,{depth:null})}); 

	/*
	> mem_mgmt
	MemMgmt {
	  start: 0,
	  end: 32,
	  used: 0,
	  lefted: 32,
	  defrag_callback:[Function (anonymous)]
	}
	> 
	*/


	var rng0 = mem_mgmt.alloc(5)
	/*
	> rng0
	[ true, 0, 5 ]
	> 
	*/

	var rng1 = mem_mgmt.alloc(23)
	/*
	rng1
	[ true, 5, 28 ]
	*/

	mem_mgmt.alloc(23)
	/*
	>
	[ false, -1, -1 ]
	> 
	*/

	mem_mgmt.free(0,28);
	/*
	[ true, [ [ 0, 5 ], [ 5, 28 ] ] ]
	*/

	mem_mgmt.alloc(2)

	/*
	[ true, 28, 30 ]
	> 
	*/

	mem_mgmt.alloc(5)
	/*
	[ true, 0, 5 ]
	> 

	> mem_mgmt.used
	7
	> mem_mgmt.lefted
	25
	> 
	*/

METHODS

   .used 
   .lefted
   .defrag_callback  

   alloc(size)                 : [succ,start_index, end_index]
   free(start_index, end_index): [Boolean, deleted_segments:Array]                                               
   defrag()                    : [new_offset_index, replace_index_pair_mat] 

APIS

LICENSE

• ISC