nv-buf-big-slab 1.1.2

package/ctor.js

@@ -0,0 +1,153 @@
+const {get_byt_from_cls,set_nth_byte,calc_prepad_sz,get_cls_from_dump_fst_byte} = require("nv-facutil-slct-ta");
+const {
+    LOAD_HINT_SZ ,
+    LOAD_HINT_CLS_BYT_IDX ,
+    LOAD_HINT_PRE_PAD_SZ_IDX,
+
+    CTRL_HEAD_CNT,SLAB_ARY_LEN_IDX,
+    SLAB_STRIDE_V,
+    slab_ctrl_bits_start_idx,
+    slab_mx_cnt_idx,
+    slab_used_cnt_idx,
+    slab_cursor_idx,
+    slab_sz_idx,
+    slab_algn_idx,
+    PTR_HEAD_CNT,DATA_PTR_IDX,
+    DATA_LOAD_HINT_SZ,
+} = require("./const");
+
+const _util = require("./util");
+
+const init_meta = (u8a,TACLS,padsz)=>{
+    var clsbyt    = get_byt_from_cls(TACLS);
+    u8a[LOAD_HINT_CLS_BYT_IDX]    = clsbyt; 
+    u8a[LOAD_HINT_PRE_PAD_SZ_IDX] = padsz;
+}
+
+const store_data_load_hint = (dv,cfg,offset)=>{
+   var N = (BigInt(cfg.data_sz)<<8n)| (BigInt(cfg.data_algn)<<4n) | BigInt(cfg.pad_bfr_data_sz);
+   if(cfg.data_inline) {} else {N=-N;}
+   dv.setBigInt64(offset,N,true);
+}
+
+const creat_tas_with_ab_and_aligned_offset = (ab,offset,cfg)=>{
+    var dv = new DataView(ab);
+    //////cpsz = LOAD_HINT_SZ + pad_bfr_ctrl_sz + ctrl_sz + LOAD_HINT_SZ + pad_bfr_ptr_sz + ptr_sz +DATA_LOAD_HINT_SZ
+    {
+        ctrl_load_hint = new Uint8Array(ab,offset,LOAD_HINT_SZ); init_meta(ctrl_load_hint,cfg.CTRL_TACLS,cfg.pad_bfr_ctrl_sz);
+        offset += LOAD_HINT_SZ;
+        pad_bfr_ctrl = new Uint8Array(ab,offset,cfg.pad_bfr_ctrl_sz);
+        offset += cfg.pad_bfr_ctrl_sz
+        ctrl_ta = new cfg.CTRL_TACLS(ab,offset, cfg.ctrl_sz/cfg.CTRL_TACLS.BYTES_PER_ELEMENT);
+        ctrl_ta[SLAB_ARY_LEN_IDX] = cfg.slab_ary.length;
+        ctrl_vw = ctrl_ta.subarray(CTRL_HEAD_CNT);
+        offset += cfg.ctrl_sz;
+        ptr_load_hint  = new Uint8Array(ab,offset,LOAD_HINT_SZ); init_meta(ptr_load_hint,cfg.PTR_TACLS,cfg.pad_bfr_ptr_sz);
+        offset += LOAD_HINT_SZ;
+        pad_bfr_ptr     = new Uint8Array(ab,offset,cfg.pad_bfr_ptr_sz);
+        offset += cfg.pad_bfr_ptr_sz;
+
+        ptr_ta  = new cfg.PTR_TACLS(ab,offset,cfg.ptr_sz/cfg.PTR_TACLS.BYTES_PER_ELEMENT);
+        ptr_ta[DATA_PTR_IDX] = cfg.data_ptr;
+        ptr_vw  = ptr_ta.subarray(PTR_HEAD_CNT);
+        offset += cfg.ptr_sz;
+        store_data_load_hint(dv,cfg,offset);
+        offset += DATA_LOAD_HINT_SZ;
+    }     
+    var rslt =  {
+        ctrl_load_hint,pad_bfr_ctrl,ctrl_ta,ctrl_vw,
+        ptr_load_hint,pad_bfr_ptr,ptr_ta,ptr_vw,
+    }
+    return [rslt,offset]
+}
+
+const creat_tas = (
+   underlying ,
+   cfg,
+   data,
+)=> {
+    var ctrl_load_hint;
+    var pad_bfr_ctrl;
+    var ctrl_ta;
+    var ctrl_vw;
+    var ptr_load_hint;
+    var pad_bfr_ptr;
+    var ptr_ta;
+    var ptr_vw;
+    ////-------------------------------------
+    var ab          = underlying.src;   var offset   = underlying.offset;
+    var data_inline = data.inline;      
+    var ta;
+    if(ab === null) {
+        if(!data.inline) {
+            ab = new ArrayBuffer(cfg.cpsz);
+        }  else {
+            ab = new ArrayBuffer(cfg.cpdsz);
+        }       
+	offset = 0;
+    } else {
+         if(!data.inline) {
+             offset += calc_prepad_sz(offset,cfg.cpalgn);
+             var diff = ab.byteLength - offset;
+             if(diff < cfg.cpsz) {
+                 throw(new Error(`ab.byteLength(${ab.byteLength}) MUST >= ${offset + cfg.cpsz}`))
+             }	 
+	 } else {
+             offset += calc_prepad_sz(offset,cfg.cpdalgn);
+             var diff = ab.byteLength - offset;
+	     if(diff < cfg.cpdsz) {
+	         throw(new Error(`ab.byteLength(${ab.byteLength}) MUST >= ${offset + cfg.cpdsz}`))
+	     }
+	 }
+    }    
+
+    ////
+    var [rslt,offset] = creat_tas_with_ab_and_aligned_offset(ab,offset,cfg);
+
+    if(!data.inline)         {
+	
+    } else                   {
+	//cpdsz = LOAD_HINT_SZ + pad_bfr_ctrl_sz + ctrl_sz + LOAD_HINT_SZ + pad_bfr_ptr_sz + ptr_sz + DATA_LOAD_HINT_SZ + pad_bfr_data_sz + data_sz
+	rslt.pad_bfr_data = new Uint8Array(ab,offset,cfg.pad_bfr_data_sz);
+        offset += cfg.pad_bfr_data_sz;
+        cfg.data_ptr = offset;	
+	_util.__updt_data_si_if_data_ptr_match_align(cfg.slab_ary,offset);
+	rslt.data = new Uint8Array(ab,offset, cfg.data_sz);
+	offset += cfg.data_sz;
+    }
+    if(ab.byteLength>=offset) {
+        return rslt;
+    } else {
+        throw(`underlying.src.byteLength(${ab.byteLength}) MUST >= ${offset}`);
+    }
+}
+
+
+const init_vws = (
+   cfg,
+   ctrl_entries,
+   ptr_vw,
+)=>{
+    var slab_ary = cfg.slab_ary;
+    var slab_ary_len = slab_ary.length;
+    for(let id=0;id<slab_ary_len;++id) {
+        var one_cfg = slab_ary[id];
+        ctrl_entries[id*SLAB_STRIDE_V+slab_ctrl_bits_start_idx]    = one_cfg.ctrl_bits_start;
+        ctrl_entries[id*SLAB_STRIDE_V+slab_mx_cnt_idx]             = one_cfg.mx_cnt;
+        ctrl_entries[id*SLAB_STRIDE_V+slab_used_cnt_idx]           = 0;
+        ctrl_entries[id*SLAB_STRIDE_V+slab_cursor_idx]             = 0;
+        ctrl_entries[id*SLAB_STRIDE_V+slab_sz_idx]                 = one_cfg.slab_sz;
+        ctrl_entries[id*SLAB_STRIDE_V+slab_algn_idx]               = one_cfg.slab_algn;
+	ptr_vw[id] = one_cfg.data_si;
+    }
+}
+
+const read_tacls = (u8a,offset)=>get_cls_from_dump_fst_byte(u8a[offset]);
+
+module.exports = {
+    init_meta,
+    store_data_load_hint,
+    creat_tas,creat_tas_with_ab_and_aligned_offset,
+    init_vws,
+    read_tacls,
+}

package/getter.js

@@ -0,0 +1,165 @@
+const {get_cls_from_dump_fst_byte} = require("nv-facutil-slct-ta");
+const {
+    LOAD_HINT_SZ ,
+    LOAD_HINT_CLS_BYT_IDX ,
+    LOAD_HINT_PRE_PAD_SZ_IDX,
+    CTRL_HEAD_CNT,SLAB_ARY_LEN_IDX,
+    SLAB_STRIDE_V,
+    slab_ctrl_bits_start_idx,
+    slab_mx_cnt_idx,
+    slab_used_cnt_idx,
+    slab_cursor_idx,
+    slab_sz_idx,
+    slab_algn_idx,
+    PTR_HEAD_CNT, DATA_PTR_IDX,
+} = require("./const");
+
+const {read_slab_ary_from_tas} = require("./util");
+
+function _underlying_ab() {return this.ctrl_load_hint.buffer;}
+function _underlying_sz() {
+    return this.ctrl_load_hint.byteLength + this._underlying_pad_sz_bfr_ctrl + this.ctrl_ta.byteLength +
+        this.ptr_load_hint.byteLength  + this._underlying_pad_sz_bfr_ptr  + this.ptr_ta.byteLength;
+}
+
+
+function _underlying_ctrl_cls()        {return get_cls_from_dump_fst_byte(this.ctrl_load_hint[LOAD_HINT_CLS_BYT_IDX])}
+function _underlying_pad_sz_bfr_ctrl() {return this.ctrl_load_hint[LOAD_HINT_PRE_PAD_SZ_IDX];}
+function _underlying_ptr_cls()         {return get_cls_from_dump_fst_byte(this.ptr_load_hint[LOAD_HINT_CLS_BYT_IDX])}
+function _underlying_pad_sz_bfr_ptr()  {return this.ptr_load_hint[LOAD_HINT_PRE_PAD_SZ_IDX];}
+
+function _underlying() {
+    return {
+        // ===== 基础 =====
+        ab: this._underlying_ab,
+        sz: this._underlying_sz,
+
+        // ===== ctrl 区 =====
+        ctrl: {
+            pool_cnt: this.pool_cnt,
+            pad_sz: this._underlying_pad_sz_bfr_ctrl,
+            cls: this._underlying_ctrl_cls,
+
+        },
+
+        // ===== ptr 区 =====
+        ptr: {
+            data_ptr: this.data_ptr,
+            pad_sz: this._underlying_pad_sz_bfr_ptr,
+            cls: this._underlying_ptr_cls,
+        },
+    }
+}
+
+
+function _pad_bfr_ctrl()               {return new Uint8Array(this.underlying_ab,this.ctrl_load_hint.byteOffset+LOAD_HINT_SZ,this.underlying_pad_sz_bfr_ctrl);}
+
+function ctrl_algn()         {return  this.CTRL_TACLS.BYTES_PER_ELEMENT;}
+// CTRL_LOAD_HINT | pad-bfr-ctrl | pool_cnt | <entries> | <ctrl_bits> | PTR_LOAD_HINT | pad-bfr-ptr | data_ptr | <data_sis>| data_info |pad_bfr_data| datas...
+//                                          |--------ctrl-view--------|                                        | ptr-view  |           |                            
+//                               |----------ctrl-ta-------------------|                             |---------ptr-ta------ |           |
+//                               |-----------ctrlsz-------------------|                             |---------ptrsz--------|           |            | datasz      
+//|----------------------------------------------------------------------------cpsz----------------------------------------------------|
+
+function pool_cnt()          {return  this.ctrl_ta[SLAB_ARY_LEN_IDX];}
+function ctrl_entries_sz()   {return  this.CTRL_TACLS.BYTES_PER_ELEMENT*(this.pool_cnt);}
+function ctrl_bits_sz()      {return  this.ptr_load_hint.byteOffset - this.ctrl_ta.byteOffset - this.CTRL_TACLS.BYTES_PER_ELEMENT*(CTRL_HEAD_CNT + this.pool_cnt);}
+function ctrl_sz()           {return  this.ptr_load_hint.byteOffset - this.ctrl_ta.byteOffset;}
+
+
+function slab_ary()      {return read_slab_ary_from_tas(this.ctrl_ta,this.ptr_ta);}
+
+
+function _pad_bfr_ptr()                {return new Uint8Array(this.underlying_ab,this.ptr_load_hint.byteOffset+LOAD_HINT_SZ,this._underlying_pad_sz_bfr_ptr);}
+function ptr_algn()                    {return this.PTR_TACLS.BYTES_PER_ELEMENT;}
+function ptr_entries_sz()              {return this.PTR_TACLS.BYTES_PER_ELEMENT*(this.pool_cnt);}
+function ptr_sz()                      {return this.PTR_TACLS.BYTES_PER_ELEMENT*(PTR_HEAD_CNT +  this.pool_cnt);}
+
+function data_ptr()  {return  this.ptr_ta[DATA_PTR_IDX];}
+function data_info() {
+    var ab     = this._underlying_ab;
+    var offset = this.ptr_ta.byteOffset + this.ptr_sz;
+    var dv     = new DataView(ab);
+    var N      = dv.getBigInt64(offset,true);
+    var inline = false;
+    if(N>0n) {inline=true;} else {N=-N;}
+    var sz              = Number(N >>8n);
+    var algn            = (N & 0xF0n) >> 4n;
+    var pad_bfr_data_sz = N & 0x0Fn;
+    return {
+	inline,
+        sz,
+	algn:Number(algn),
+	pad_bfr_data_sz:Number(pad_bfr_data_sz)
+    }
+}
+
+function data_sz()          {return this.data_info.sz}
+function data_algn()        {return this.data_info.algn}
+function cond_data_inline() {return this.data_info.inline}
+function _pad_bfr_data()    {
+    if(this.cond_data_inline) {
+	var pad_bfr_data_sz = this.data_info.pad_bfr_data_sz;
+	var offset = this.ptr_ta.byteOffset + this.ptr_sz + 8;
+        return new Uint8Array(this.underlying_ab,offset,offset + pad_bfr_data_sz);
+    } else {
+        return null;
+    }
+}
+function _data_ptr_if_inline() {
+    var pad_bfr_data_sz = this.data_info.pad_bfr_data_sz;
+    return  this.ptr_ta.byteOffset + this.ptr_sz + 8 + pad_bfr_data_sz;
+}
+function _cond_data_ptr_valid() {
+    if(this.cond_data_inline) {
+        return (this._data_ptr_if_inline === this.data_ptr);
+    } else {
+        return true;
+    }    
+}
+
+function cpalgn() {return Math.max(this.ctrl_algn,this.ptr_algn)}
+function cpsz()   {return LOAD_HINT_SZ + this._underlying_pad_sz_bfr_ctrl + this.ctrl_sz + LOAD_HINT_SZ + this._underlying_pad_sz_bfr_ptr + this.ptr_sz +8;}
+
+function cpdalgn() {return Math.max(this.cpalgn,this.data_algn)}
+function cpdsz()   {var info = this.data_info;return this.cpsz + info.pad_bfr_data_sz + info.sz;}
+
+function stats() {
+    var d = {}; var D={};
+    var arr = this.slab_ary;
+    for(let e of arr) {
+        var k = `sz = ${e.slab_sz}`.padEnd(24) + `align = ${e.slab_algn}    `.padEnd(8) + "|";
+        var v = "|" + ` used_cnt = ${e.used_cnt}`.padEnd(24) + `unused_cnt = ${e.mx_cnt-e.used_cnt}`.padEnd(24);
+	if(e.used_cnt<e.mx_cnt) {
+            d[k] = v;
+	} else {
+	    D[k] = v;
+	}
+    }
+    return {
+       alocable:d,
+       unalocable:D,
+    };
+}
+
+module.exports = {
+    _underlying,
+    _underlying_ab,_underlying_sz,
+    _underlying_ctrl_cls,_underlying_pad_sz_bfr_ctrl,
+    _pad_bfr_ctrl,
+    ctrl_algn,pool_cnt,ctrl_entries_sz,ctrl_sz,
+    _underlying_ptr_cls,_underlying_pad_sz_bfr_ptr,
+    _pad_bfr_ptr,
+    ptr_algn,ptr_sz,ptr_entries_sz,
+    ////
+    data_ptr, _data_ptr_if_inline,_cond_data_ptr_valid,
+    _pad_bfr_data,
+    data_info, data_algn,data_sz, cond_data_inline,
+    ////
+    slab_ary,
+    stats,
+    ////
+    cpalgn,cpsz,
+    cpdalgn,cpdsz,
+}
+

package/index.js

@@ -0,0 +1,261 @@
+const _patch       = require("nv-facutil-simple-patch-cls");
+const FRZ          = require("nv-facutil-deep-freeze-j");
+const {get_nth_byte,get_cls_from_dump_fst_byte,calc_prepad_sz,read_dv_with_cls,    fmt_underlying,fmt_data} = require("nv-facutil-slct-ta");
+const {calc_slab_info,slct_slab} = require("./util");
+const _const = require("./const");
+const _util  = require("./util");
+const _ctor  = require("./ctor")
+
+
+const {
+    LOAD_HINT_SZ ,
+    LOAD_HINT_CLS_BYT_IDX ,
+    LOAD_HINT_PRE_PAD_SZ_IDX,
+    ////
+    CTRL_HEAD_CNT,SLAB_ARY_LEN_IDX,
+    SLAB_STRIDE_V,
+    slab_ctrl_bits_start_idx,
+    slab_mx_cnt_idx,
+    slab_used_cnt_idx,
+    slab_cursor_idx,
+    slab_sz_idx,
+    slab_algn_idx,
+    PTR_HEAD_CNT, DATA_PTR_IDX,
+} = require("./const");
+
+const creat_dflt_cfg = ()=>{
+    var cfg = _const.DFLT_CFG();
+    return _util.merge_slab_ary(_util.sort_slab_ary(_util.dict_cfg_to_ary_cfg(cfg)));
+}
+const calc_dflt_slab_info =(data_ptr=0)=>calc_slab_info(creat_dflt_cfg(),data_ptr);
+
+
+
+////
+function Slabs(ctrl_load_hint,ctrl_ta,ptr_load_hint, ptr_ta) {
+    var len = ctrl_ta[SLAB_ARY_LEN_IDX];
+    _patch.def_ps(this,{
+        CTRL_TACLS:             ctrl_ta.constructor,
+        bit_cnt_per_unit_v: 8 * ctrl_ta.constructor.BYTES_PER_ELEMENT,
+        ctrl_load_hint,
+        ctrl_ta,
+        ctrl_vw:                ctrl_ta.subarray(CTRL_HEAD_CNT),
+        ctrl_entries:           ctrl_ta.subarray(CTRL_HEAD_CNT, CTRL_HEAD_CNT+len),
+        PTR_TACLS:              ptr_ta.constructor,
+        ptr_load_hint,
+        ptr_ta,
+        ptr_vw:                 ptr_ta.subarray(PTR_HEAD_CNT),
+    });
+}
+const _getters = require("./getter");
+const _mthds   = require("./mthd");
+_patch.add_getters(Slabs,_getters);
+_patch.add_mthds(Slabs,_mthds);
+Object.defineProperty(Slabs.prototype,Symbol.toStringTag,{get:function(){return JSON.stringify(this.stats,null,2)}});
+
+/////
+
+const creat_non_inline_on_aligned_external_ab_aft_calc_cfg =(
+    ab,offset,
+    cfg,
+    data_ptr,
+)=>{
+    cfg.data_inline = false;
+    cfg.data_ptr    = data_ptr;    
+    const [{ctrl_load_hint,ctrl_ta,ptr_load_hint, ptr_ta,ctrl_vw,ptr_vw},new_offset] = _ctor.creat_tas_with_ab_and_aligned_offset(ab,offset,cfg);
+    _ctor.init_vws(cfg,ctrl_vw,ptr_vw);
+    return new Slabs(ctrl_load_hint,ctrl_ta,ptr_load_hint, ptr_ta); 
+}
+
+
+
+////
+
+const creat_on_external_ab = (
+    underlying, // ArrayBuffer | {src:ArrayBuffer,offset:Number}
+    cfg  = creat_dflt_cfg(),
+    data = {ptr:0,inline:false} // Number | {inline:fasle,ptr:Number} 
+) => {
+    underlying = fmt_underlying(underlying); 
+    data  = fmt_data(data);
+    cfg   = _util.calc_slab_info(cfg,data);
+    const {ctrl_load_hint,ctrl_ta,ptr_load_hint, ptr_ta,ctrl_vw,ptr_vw} = _ctor.creat_tas(underlying,cfg,data);
+    _ctor.init_vws(cfg,ctrl_vw,ptr_vw);
+    return new Slabs(ctrl_load_hint,ctrl_ta,ptr_load_hint, ptr_ta);
+}
+const creat = (cfg=creat_dflt_cfg(),data={ptr:0,inline:false})=>creat_on_external_ab(null,cfg,data);
+
+const preload = (u8a)=>{
+    var offset = 0;
+    const CTRL_TACLS = get_cls_from_dump_fst_byte(u8a[offset]);                      // CLS_BYT
+    offset += 1;
+    const ctrl_algn = CTRL_TACLS.BYTES_PER_ELEMENT;
+    const pad_bfr_ctrl_sz = u8a[offset];                                             // pad-bfr-ctrl  
+    offset += 1;
+    offset += pad_bfr_ctrl_sz;                                                    var ctrl_ta_offset = offset;
+    var dv = new DataView(u8a.buffer,u8a.byteOffset,u8a.byteLength);
+    const pool_cnt = read_dv_with_cls(dv,CTRL_TACLS,offset,true);
+    offset +=  CTRL_TACLS.BYTES_PER_ELEMENT;
+    var total_ctrl_bits_sz = 0;
+
+    for(let slab_id =0; slab_id<pool_cnt; slab_id++) {
+        offset += CTRL_TACLS.BYTES_PER_ELEMENT * SLAB_STRIDE_V;
+        var mx_cnt  = read_dv_with_cls(dv,CTRL_TACLS, offset + slab_mx_cnt_idx,true);
+        total_ctrl_bits_sz += _util.calc_ctrl_bits_sz(mx_cnt,CTRL_TACLS);
+    }
+    offset += total_ctrl_bits_sz;
+    const PTR_TACLS = get_cls_from_dump_fst_byte(u8a[offset]);// CLS_BYT
+    offset += 1;
+    const ptr_algn = PTR_TACLS.BYTES_PER_ELEMENT;
+    const pad_bfr_ptr_sz = u8a[offset];                      // pad-bfr-ctrl
+    offset += 1;
+    offset += pad_bfr_ptr_sz;                                                var ptr_ta_offset = offset;
+    const data_ptr = read_dv_with_cls(dv,PTR_TACLS,offset,true);
+    offset +=  PTR_TACLS.BYTES_PER_ELEMENT;                                  var ptr_entries_offset = offset;
+    offset +=  PTR_TACLS.BYTES_PER_ELEMENT *pool_cnt;
+    var N = read_dv_with_cls(dv,BigInt64Array,offset,true);
+    const data_inline = N >0;
+    if(N<0n) {N=-N;}
+    const data_sz         = Number(N >>8n);
+    const data_algn       = Number((N & 0xF0n) >> 4n);
+    const pad_bfr_data_sz = Number(N&0x0Fn);
+    offset += 8;
+    const cp_algn  = Math.max(ctrl_algn,ptr_algn);
+    const cp_sz    = offset;
+    return {
+        offset,
+        CTRL_TACLS,           ctrl_algn,ctrl_ta_offset,pool_cnt,   pad_bfr_ctrl_sz,
+        PTR_TACLS,            ptr_algn, ptr_ta_offset, data_ptr,   pad_bfr_ptr_sz,
+        data_inline,data_algn,data_sz,pad_bfr_data_sz,
+        cp_algn, cp_sz,        
+    }
+}
+
+const load_non_inline_aft_preload = (u8a,preload_info)=>{
+    var abs_offset = u8a.byteOffset;
+    let {
+        offset,
+        CTRL_TACLS,           ctrl_algn,ctrl_ta_offset,pool_cnt,   pad_bfr_ctrl_sz,
+        PTR_TACLS,            ptr_algn, ptr_ta_offset, data_ptr,   pad_bfr_ptr_sz,
+        data_inline,data_algn,data_sz,pad_bfr_data_sz,
+        cp_algn, cp_sz,
+    } = preload_info;    
+    const total_sz = offset;
+    if(u8a.byteLength < total_sz) {throw(`u8a.byteLength(${u8a.byteLength}) MUST >= ${total_sz}`)}
+    if(abs_offset % cp_algn === 0) {
+    } else {
+        u8a = u8a.slice(0);
+        abs_offset = 0;           
+    }
+    {
+        var ctrl_load_hint = u8a.subarray(0,LOAD_HINT_SZ);
+        var ctrl_ta        = new CTRL_TACLS(u8a.buffer,abs_offset + LOAD_HINT_SZ, (ptr_ta_offset-  pad_bfr_ptr_sz - LOAD_HINT_SZ - ctrl_ta_offset)/CTRL_TACLS.BYTES_PER_ELEMENT);
+        var ptr_load_hint  = u8a.subarray(ptr_ta_offset-LOAD_HINT_SZ, ptr_ta_offset);
+        var ptr_ta         = new PTR_TACLS(u8a.buffer,abs_offset + ptr_ta_offset, PTR_HEAD_CNT + pool_cnt);
+        return new Slabs(ctrl_load_hint,ctrl_ta,ptr_load_hint, ptr_ta);
+    }
+}
+
+const load_inline_aft_preload = (u8a,preload_info)=>{
+    var abs_offset = u8a.byteOffset;
+    let {
+        offset,
+        CTRL_TACLS,           ctrl_algn,ctrl_ta_offset,pool_cnt,   pad_bfr_ctrl_sz,
+        PTR_TACLS,            ptr_algn, ptr_ta_offset, data_ptr,   pad_bfr_ptr_sz,
+        data_inline,data_algn,data_sz,pad_bfr_data_sz,
+        cp_algn, cp_sz,
+    } = preload_info;
+    offset +=   pad_bfr_data_sz;                                         var data_offset = offset;
+    const total_sz = offset +data_sz;
+    const cpd_algn = Math.max(cp_algn,data_algn);
+    if(u8a.byteLength < total_sz) {throw(`u8a.byteLength(${u8a.byteLength}) MUST >= ${total_sz}`)}
+    if(abs_offset % cpd_algn === 0) {
+    } else {
+        u8a = u8a.slice(0);
+        abs_offset = 0;
+    }
+    {
+        var ctrl_load_hint = u8a.subarray(0,LOAD_HINT_SZ);
+        var ctrl_ta        = new CTRL_TACLS(u8a.buffer,abs_offset + LOAD_HINT_SZ, (ptr_ta_offset-  pad_bfr_ptr_sz - LOAD_HINT_SZ - ctrl_ta_offset)/CTRL_TACLS.BYTES_PER_ELEMENT);
+        var ptr_load_hint  = u8a.subarray(ptr_ta_offset-LOAD_HINT_SZ, ptr_ta_offset);
+        var ptr_ta         = new PTR_TACLS(u8a.buffer,abs_offset + ptr_ta_offset, PTR_HEAD_CNT + pool_cnt);
+        // 修正指针
+        ptr_ta[DATA_PTR_IDX] = abs_offset + data_offset;
+        var ptr_vw = ptr_ta.subarray(PTR_HEAD_CNT);
+        var diff = ptr_ta[DATA_PTR_IDX] - data_ptr;
+        for(let slab_id=0;slab_id<pool_cnt;++slab_id) {ptr_vw[slab_id] += diff;}
+        return new Slabs(ctrl_load_hint,ctrl_ta,ptr_load_hint, ptr_ta);
+    }
+}
+
+const load  = (u8a)=> {
+    const preload_info = preload(u8a);
+    if(inline) {
+        return load_inline_aft_preload(u8a,preload_info);
+    } else     {
+        return load_non_inline_aft_preload(u8a,preload_info);
+    }
+}
+
+
+
+class Buf {
+    slabs;
+    data;
+    constructor(slabs,u8a) {
+        this.slabs = slabs; 
+        this.data  = data;
+        Object.seal(this);
+    }
+    dump() {return this.slabs.dump()}
+    aloc(sz,algn=1) {
+        var [ei,si] = this.slabs.aloc(sz,algn);
+        return this.data.subarray(si,ei);
+    }
+    dloc(u8a) {
+        if(u8a.buffer === this.data.buffer) {
+            var si = u8a.byteOffset;
+            return this.slabs.dloc(si);
+        } else {
+            return false;
+        }
+    }
+}
+const _new_buf = (slabs,u8a)=>new Buf(slabs,u8a);
+const new_buf_on_external_ab = (underlying,cfg=creat_dflt_cfg()) => {
+    const data = {ptr:0,inline:true};
+    cfg   = _util.calc_slab_info(cfg,data);
+    const rslt =  _ctor.creat_tas(underlying,cfg,data);
+    const {ctrl_load_hint,ctrl_ta,ptr_load_hint, ptr_ta,ctrl_vw,ptr_vw} = rslt;
+    _ctor.init_vws(cfg,ctrl_vw,ptr_vw);
+    return _new_buf(new Slabs(ctrl_load_hint,ctrl_ta,ptr_load_hint, ptr_ta),rslt.data);
+}
+const  new_buf = (cfg=creat_dflt_cfg())=>new_buf_on_external_ab(null,cfg);
+const load_buf    = (u8a)=>{
+    var slabs     = load(u8a);
+    var data_byts = u8a.subarray(slabs._data_ptr_if_inline);
+    return _new_buf(slabs,data_byts);
+}
+
+
+module.exports = creat;
+module.exports.load  = load;
+module.exports.creat_on_external_ab = creat_on_external_ab;
+module.exports.creat_dflt_cfg = creat_dflt_cfg;
+module.exports.calc_dflt_slab_info = calc_dflt_slab_info;
+module.exports.creat_non_inline_on_aligned_external_ab_aft_calc_cfg = creat_non_inline_on_aligned_external_ab_aft_calc_cfg;
+module.exports.preload = preload;
+module.exports.load_non_inline_aft_preload = load_non_inline_aft_preload;
+module.exports.load_inline_aft_preload     = load_inline_aft_preload;
+
+module.exports.new_buf = new_buf;
+module.exports.load_buf = load_buf;
+module.exports.new_buf_on_external_ab = new_buf_on_external_ab;
+_patch.def_ps(module.exports,{
+    Slabs,
+    Buf,
+    _util,
+    _const,
+});
+
+