react-native-update 10.34.2 → 10.34.3

package/harmony/pushy/src/main/cpp/HDiffPatch/libHDiffPatch/HPatch/hpatch_mt/_patch_private_mt.h

@@ -0,0 +1,217 @@
+//  _patch_private_mt.h
+//  hpatch
+/*
+ The MIT License (MIT)
+ Copyright (c) 2025 HouSisong
+ 
+ Permission is hereby granted, free of charge, to any person
+ obtaining a copy of this software and associated documentation
+ files (the "Software"), to deal in the Software without
+ restriction, including without limitation the rights to use,
+ copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the
+ Software is furnished to do so, subject to the following
+ conditions:
+ 
+ The above copyright notice and this permission notice shall be
+ included in all copies of the Software.
+ 
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ OTHER DEALINGS IN THE SOFTWARE.
+*/
+#ifndef _patch_private_mt_h
+#define _patch_private_mt_h
+#include "_hpatch_mt.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+#if (_IS_USED_MULTITHREAD)
+
+#define _thread_obj_free(free_fn,th_obj) { if (th_obj) { free_fn(th_obj); th_obj=0; } }
+
+typedef struct hpatch_TWorkBuf{
+    struct hpatch_TWorkBuf* next;
+    size_t                  data_size;
+    //hpatch_byte           data[workBufSize];
+} hpatch_TWorkBuf;
+hpatch_force_inline static
+hpatch_byte* TWorkBuf_data(hpatch_TWorkBuf* self) { return ((hpatch_byte*)self)+sizeof(hpatch_TWorkBuf); }
+hpatch_force_inline static
+hpatch_byte* TWorkBuf_data_end(hpatch_TWorkBuf* self) { return TWorkBuf_data(self)+self->data_size; }
+hpatch_inline static
+hpatch_size_t TWorkBuf_bufCount(const hpatch_TWorkBuf* self) {
+    const hpatch_TWorkBuf* cur=self;
+    hpatch_size_t count=0;
+    while (cur){
+        ++count;
+        cur=cur->next;
+    }
+    return count;
+}
+
+hpatch_force_inline static
+void TWorkBuf_pushABufAtEnd(hpatch_TWorkBuf** pnode,hpatch_TWorkBuf* data){
+    while (*pnode)
+        pnode=&(*pnode)->next;
+    data->next=0;
+    *pnode=data;
+}
+
+hpatch_force_inline static
+void TWorkBuf_pushABufAtHead(hpatch_TWorkBuf** pnode,hpatch_TWorkBuf* data){
+    data->next=*pnode;
+    *pnode=data;
+}
+
+hpatch_force_inline static
+hpatch_TWorkBuf* TWorkBuf_popABuf(hpatch_TWorkBuf** pnode){
+    hpatch_TWorkBuf* result=*pnode;
+    *pnode=(result)?result->next:0;
+    return result;
+}
+
+hpatch_force_inline static
+hpatch_TWorkBuf* TWorkBuf_popAllBufs(hpatch_TWorkBuf** pnode){
+    hpatch_TWorkBuf* result=*pnode;
+    *pnode=0;
+    return result;
+}
+
+hpatch_force_inline static 
+size_t TWorkBuf_getWorkBufSize(size_t workBufNodeSize){
+                                    assert(workBufNodeSize>sizeof(hpatch_TWorkBuf));
+                                    return workBufNodeSize-sizeof(hpatch_TWorkBuf); }
+hpatch_inline static
+hpatch_TWorkBuf* TWorkBuf_createFreeListAt(hpatch_byte* pbuf,size_t workBufCount,size_t workBufNodeSize) {
+    hpatch_TWorkBuf* result = 0;
+    for (; (workBufCount--)>0;pbuf+= workBufNodeSize)
+        TWorkBuf_pushABufAtHead(&result, (hpatch_TWorkBuf*)pbuf);
+    return result;
+}
+hpatch_force_inline static
+hpatch_TWorkBuf* TWorkBuf_allocFreeList(hpatch_byte** pmem,size_t workBufCount,size_t workBufNodeSize) {
+    hpatch_TWorkBuf* result=TWorkBuf_createFreeListAt((*pmem),workBufCount,workBufNodeSize);
+    (*pmem)+=workBufCount*workBufNodeSize;
+    return result;
+}
+
+typedef struct hpatch_mt_base_t{
+    struct hpatch_mt_t*         h_mt;
+    size_t                      workBufSize;
+    volatile hpatch_TWorkBuf*   freeBufList;
+    volatile hpatch_TWorkBuf*   dataBufList;
+    volatile hpatch_BOOL        isOnError;
+#if (defined(_DEBUG) || defined(DEBUG))
+    volatile size_t             threadIsRunning;
+#endif
+    HLocker     _locker;
+    HCondvar    _waitCondvar;
+} hpatch_mt_base_t;
+
+
+hpatch_BOOL         _hpatch_mt_base_init(hpatch_mt_base_t* self,struct hpatch_mt_t* h_mt,hpatch_TWorkBuf* freeBufList,hpatch_size_t workBufSize);
+void                _hpatch_mt_base_free(hpatch_mt_base_t* self);
+void                hpatch_mt_base_setOnError_(hpatch_mt_base_t* self);
+hpatch_TWorkBuf*    hpatch_mt_base_onceWaitABuf_(hpatch_mt_base_t* self,hpatch_TWorkBuf** pBufList,hpatch_BOOL* _isOnError);
+hpatch_TWorkBuf*    hpatch_mt_base_onceWaitAllBufs_(hpatch_mt_base_t* self,hpatch_TWorkBuf** pBufList,hpatch_BOOL* _isOnError);
+void                hpatch_mt_base_pushABufAtEnd_(hpatch_mt_base_t* self,hpatch_TWorkBuf** pBufList,hpatch_TWorkBuf* wbuf,hpatch_BOOL* _isOnError);
+void                hpatch_mt_base_pushABufAtHead_(hpatch_mt_base_t* self,hpatch_TWorkBuf** pBufList,hpatch_TWorkBuf* wbuf,hpatch_BOOL* _isOnError);
+hpatch_BOOL         hpatch_mt_base_threadsBegin_(hpatch_mt_base_t* self,int threadCount,TThreadRunCallBackProc threadProc,
+                                                 void* workData,int isUseThisThread,int threadIndexOffset);
+hpatch_force_inline static
+hpatch_BOOL         hpatch_mt_base_aThreadBegin_(hpatch_mt_base_t* self,TThreadRunCallBackProc threadProc,void* workData){
+                                                    return hpatch_mt_base_threadsBegin_(self,1,threadProc,workData,hpatch_FALSE,0); }
+hpatch_force_inline static
+void                hpatch_mt_base_aThreadEnd_(hpatch_mt_base_t* self){
+                                                #if (defined(_DEBUG) || defined(DEBUG))
+                                                    c_locker_enter(self->_locker);
+                                                    assert(self->threadIsRunning);
+                                                    --self->threadIsRunning;
+                                                    c_locker_leave(self->_locker);
+                                                #endif
+                                                    if (self->h_mt)
+                                                        hpatch_mt_onThreadEnd(self->h_mt);
+                                                }
+
+                                                
+#define _DEF_hinput_mt_base_read() {    \
+    hpatch_BOOL _isOnError=hpatch_FALSE;            \
+    while ((!_isOnError)&(out_data<out_data_end)){  \
+        if (self->curDataBuf==0){       \
+            if (hpatch_mt_isOnError(self->mt_base.h_mt)) { _isOnError=hpatch_TRUE; break; }     \
+            self->curDataBuf=hpatch_mt_base_onceWaitABuf_(&self->mt_base,(hpatch_TWorkBuf**)&self->mt_base.dataBufList,&_isOnError);       \
+        }       \
+        if ((self->curDataBuf!=0)&(!_isOnError)){   \
+            size_t readLen=self->curDataBuf->data_size-self->curDataBuf_pos;                    \
+            readLen=(readLen<(size_t)(out_data_end-out_data))?readLen:(size_t)(out_data_end-out_data);                  \
+            memcpy(out_data,TWorkBuf_data(self->curDataBuf)+self->curDataBuf_pos,readLen);      \
+            self->curDataBuf_pos+=readLen;          \
+            out_data+=readLen;          \
+            if (self->curDataBuf_pos==self->curDataBuf->data_size){ \
+                hpatch_mt_base_pushABufAtHead_(&self->mt_base,(hpatch_TWorkBuf**)&self->mt_base.freeBufList,self->curDataBuf,&_isOnError); \
+                self->curDataBuf=0;     \
+                self->curDataBuf_pos=0; \
+            }   \
+        }       \
+    }           \
+    return (!_isOnError); }
+
+
+typedef struct _hthreads_waiter_t{
+    volatile unsigned int   runningThreads;
+    HLocker                 _threadsEndLocker;
+    HCondvar                _threadsEndCondvar;
+} _hthreads_waiter_t;
+
+hpatch_force_inline static
+hpatch_BOOL _hthreads_waiter_init(_hthreads_waiter_t* self){
+    assert((self->runningThreads==0)&&(self->_threadsEndLocker==0)&&(self->_threadsEndCondvar==0));
+    self->_threadsEndLocker=c_locker_new();
+    self->_threadsEndCondvar=c_condvar_new();
+    return (self->_threadsEndCondvar!=0)&(self->_threadsEndLocker!=0);
+}
+
+hpatch_force_inline static
+void _hthreads_waiter_free(_hthreads_waiter_t* self){
+    assert(self->runningThreads==0);
+    _thread_obj_free(c_locker_delete,self->_threadsEndLocker);
+    _thread_obj_free(c_condvar_delete,self->_threadsEndCondvar);
+}
+
+hpatch_force_inline static
+void _hthreads_waiter_inc(_hthreads_waiter_t* self){
+    c_locker_enter(self->_threadsEndLocker);
+    ++self->runningThreads;
+    c_locker_leave(self->_threadsEndLocker);
+}
+
+hpatch_force_inline static
+void _hthreads_waiter_dec(_hthreads_waiter_t* self){
+    c_locker_enter(self->_threadsEndLocker);
+    assert(self->runningThreads>0); //logic error!
+    --self->runningThreads;
+    if (self->runningThreads==0)
+        c_condvar_signal(self->_threadsEndCondvar);
+    c_locker_leave(self->_threadsEndLocker);
+}
+
+hpatch_force_inline static
+void _hthreads_waiter_waitAllThreadEnd(_hthreads_waiter_t* self){
+    c_locker_enter(self->_threadsEndLocker);
+    while (self->runningThreads){
+        c_condvar_wait(self->_threadsEndCondvar,self->_threadsEndLocker);
+    }
+    c_locker_leave(self->_threadsEndLocker);
+}
+
+#endif //_IS_USED_MULTITHREAD
+#ifdef __cplusplus
+}
+#endif
+#endif //_patch_private_mt_h

package/harmony/pushy/src/main/cpp/HDiffPatch/libHDiffPatch/HPatch/hpatch_mt/hpatch_mt.c

@@ -0,0 +1,349 @@
+//  hpatch_mt.c
+//  hpatch
+/*
+ The MIT License (MIT)
+ Copyright (c) 2025 HouSisong
+ 
+ Permission is hereby granted, free of charge, to any person
+ obtaining a copy of this software and associated documentation
+ files (the "Software"), to deal in the Software without
+ restriction, including without limitation the rights to use,
+ copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the
+ Software is furnished to do so, subject to the following
+ conditions:
+ 
+ The above copyright notice and this permission notice shall be
+ included in all copies of the Software.
+ 
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ OTHER DEALINGS IN THE SOFTWARE.
+*/
+#include "hpatch_mt.h"
+#include "../patch_private.h"
+#include "../patch.h"
+
+#if (_IS_USED_MULTITHREAD)
+#include "_patch_private_mt.h"
+#include "_hcache_old_mt.h"
+#include "_hinput_mt.h"
+#include "_houtput_mt.h"
+#include "_hpatch_mt.h"
+#ifndef _MT_IS_NEED_LIMIT_SIZE
+#   define _MT_IS_NEED_LIMIT_SIZE   1
+#endif
+
+    const size_t kAlignSize=sizeof(hpatch_StreamPos_t);
+    const size_t kMinBufNodeSize=hpatch_kStreamCacheSize;
+    const size_t kBetterBufNodeSize=hpatch_kFileIOBufBetterSize;
+    const size_t kObjNodeCount=2;
+    static size_t _getObjsMemSize(hpatchMTSets_t mtsets,size_t* pworkBufCount);
+
+    // [writeNew,readOld,readDiff,decompressDiff]
+    typedef hpatch_byte disThreads_t[4];
+    static const disThreads_t _disThreadsTab_2[4]=
+        { {1,0,0,0},{0,1,0,0},{0,0,1,0},{0,0,0,1} };
+    static const disThreads_t _disThreadsTab_3[6]=
+        { {1,1,0,0},{1,0,1,0},{1,0,0,1},{0,1,1,0},{0,1,0,1},{0,0,1,1} };
+    static const disThreads_t _disThreadsTab_4[4]=
+        { {1,1,1,0},{1,1,0,1},{1,0,1,1},{0,1,1,1} };
+    static const disThreads_t _disThreadsTab_5[1]=
+        { {1,1,1,1} };
+
+    #define _define_times5(_times) \
+        const hpatch_uint64_t _times[5] = { writeNewTime,readOldTime,readDiffTime,decompressTime,patchTime }
+
+    static hpatch_uint64_t _runTimeByDisThreads(const disThreads_t curThreads,const hpatch_uint64_t times[5]) {
+        hpatch_uint64_t pT = times[4]; //patch
+        hpatch_uint64_t dT = times[3]; //decompress
+        hpatch_uint64_t maxT=0;
+        if (curThreads[0]) //writeNewTime
+            maxT=(times[0]>maxT)?times[0]:maxT;
+        else
+            pT+=times[0];
+        if (curThreads[1]) //readOld
+            maxT=(times[1]>maxT)?times[1]:maxT;
+        else
+            pT+=times[1];
+        if (curThreads[2]) //readDiff
+            maxT=(times[2]>maxT)?times[2]:maxT;
+        else
+            dT+=times[2];
+        if (curThreads[3]) //decompressDiff
+            maxT=(dT>maxT)?dT:maxT;
+        else
+            pT+=dT;
+        return (pT>maxT)?pT:maxT;
+    }
+    static hpatch_inline hpatch_uint64_t _sumTimeByDisThreads(const disThreads_t curThreads, const hpatch_uint64_t times[5]) {
+        return times[0]*curThreads[0]+times[1]*curThreads[1]+times[2]*curThreads[2]+times[3]*curThreads[3];
+    }
+    
+    static hpatch_uint64_t _distributeThread(disThreads_t disThreads,const hpatch_uint64_t times[5],
+                                             size_t maxThreadNum,hpatchMTSets_t mtsets){
+        size_t i;
+        hpatch_uint64_t minTime=~(hpatch_uint64_t)0;
+        const disThreads_t* disThreadsTab;
+        size_t disThreadsTabCount;
+        size_t threadNum=_hpatchMTSets_threadNum(mtsets);
+        threadNum=threadNum<maxThreadNum?threadNum:maxThreadNum;
+        if (threadNum==2){
+            disThreadsTab=_disThreadsTab_2;
+            disThreadsTabCount=sizeof(_disThreadsTab_2)/sizeof(disThreads_t);
+        }else if (threadNum==3){
+            disThreadsTab=_disThreadsTab_3;
+            disThreadsTabCount=sizeof(_disThreadsTab_3)/sizeof(disThreads_t);
+        }else if (threadNum==4){
+            disThreadsTab=_disThreadsTab_4;
+            disThreadsTabCount=sizeof(_disThreadsTab_4)/sizeof(disThreads_t);
+        }else{
+            disThreadsTab=_disThreadsTab_5;
+            disThreadsTabCount=sizeof(_disThreadsTab_5)/sizeof(disThreads_t);
+        }
+        for (i=0;i<disThreadsTabCount;++i){
+            size_t        j;
+            hpatch_uint64_t curTime;
+            disThreads_t  curThreads;
+            for (j=0;j<sizeof(disThreads_t)/sizeof(disThreads[0]);++j)
+                curThreads[j]=disThreadsTab[i][j]&((hpatch_byte*)&mtsets)[j];
+            if (_hpatchMTSets_threadNum(*(hpatchMTSets_t*)curThreads)!=threadNum) continue;
+            curTime=_runTimeByDisThreads(curThreads,times);
+            if (curTime<=minTime){
+                if (curTime==minTime){
+                    if (_sumTimeByDisThreads(curThreads,times)<_sumTimeByDisThreads(disThreads,times))
+                        continue;
+                }
+                memcpy(disThreads,curThreads,sizeof(disThreads_t));
+                minTime=curTime;
+            }
+        }
+        assert(_hpatchMTSets_threadNum(*(hpatchMTSets_t*)disThreads)==threadNum);
+        return minTime;
+    }
+
+hpatchMTSets_t _hpatch_getMTSets(hpatch_StreamPos_t newSize,hpatch_StreamPos_t oldSize,hpatch_StreamPos_t diffSize,
+                                const hpatch_TDecompress* decompressPlugin,size_t kCacheCount,size_t stepMemSize,
+                                size_t temp_cacheSumSize,size_t maxThreadNum,hpatchMTSets_t mtsets){
+    hpatch_uint64_t writeNewTime,readOldTime,readDiffTime,decompressTime,patchTime;
+    hpatch_uint64_t readOldSpeed=25;
+    assert(sizeof(disThreads_t)==sizeof(hpatchMTSets_t));
+    assert((2<=maxThreadNum));
+#if (_MT_IS_NEED_LIMIT_SIZE)
+    if (newSize<1*(1<<20)) mtsets.writeNew_isMT=0;
+    if (oldSize<1*(1<<17)) mtsets.readOld_isMT=0;
+    if ((diffSize<(newSize+oldSize)/256)|(diffSize<(1<<17))) mtsets.readDiff_isMT=0;
+#endif
+    if (decompressPlugin==0) mtsets.decompressDiff_isMT=0;
+    if (mtsets.readOld_isMT){// is can cache all old?
+        size_t workBufCount,objsMemSize,kMinTempCacheSize;
+        hpatchMTSets_t _mtsets=mtsets; _mtsets.readOld_isMT=0;
+        objsMemSize=_getObjsMemSize(_mtsets,&workBufCount);
+        kMinTempCacheSize=objsMemSize+kMinBufNodeSize*(workBufCount+kCacheCount)+(kAlignSize-1);
+        if (_patch_is_can_cache_all_old(oldSize,stepMemSize+kMinTempCacheSize,temp_cacheSumSize)){
+            mtsets.readOld_isMT=0; //old data will load in memery, no need MT.
+            readOldSpeed*=1000; //old in memory
+        }
+    #if (_IS_NEED_CACHE_OLD_BY_COVERS)
+        else{ //is can cache part of old by step?
+            kMinTempCacheSize=objsMemSize+kBetterBufNodeSize*(workBufCount+kCacheCount)+(kAlignSize-1);
+            if (_patch_step_cache_old_canUsedSize(stepMemSize,kMinTempCacheSize,temp_cacheSumSize)>0){
+                mtsets.readOld_isMT=0; // not use MT.
+                readOldSpeed*=2; //cache part of old by step
+            }
+        }
+    #endif // _IS_NEED_CACHE_OLD_BY_COVERS
+    }else{
+        readOldSpeed*=1000; //old in memory
+    }
+    if (_hpatchMTSets_threadNum(mtsets)<=1) return hpatchMTSets_no;
+    { // estimate run time of each part
+        hpatch_uint64_t newInDiffSize=diffSize/(decompressPlugin?1:2);
+        hpatch_uint64_t decompressSpeed;
+        if (decompressPlugin==0)
+            decompressSpeed=0; //not used
+        else if (decompressPlugin->is_can_open("zstd"))
+            decompressSpeed=55;
+        else if (decompressPlugin->is_can_open("lzma2")||decompressPlugin->is_can_open("lzma"))
+            decompressSpeed=10;
+        else if (decompressPlugin->is_can_open("zlib"))
+            decompressSpeed=30;
+        else if (decompressPlugin->is_can_open("bzip2"))
+            decompressSpeed=5;
+        else if (decompressPlugin->is_can_open("brotli"))
+            decompressSpeed=35;
+        else
+            decompressSpeed=30/*unknow*/;
+        decompressTime=mtsets.decompressDiff_isMT?diffSize/decompressSpeed:0;
+        writeNewTime=mtsets.writeNew_isMT?newSize/100:0;
+        readDiffTime=mtsets.readDiff_isMT?diffSize/150:0;
+        patchTime=newSize/300;
+        readOldTime=((oldSize<newInDiffSize?0:oldSize-newInDiffSize)+oldSize/8)/readOldSpeed;
+    }
+    { // distribute thread
+        size_t   i;
+        _define_times5(times);
+        disThreads_t disThreads={0,0,0,0};
+        hpatch_uint64_t minTime=_distributeThread(disThreads,times,maxThreadNum,mtsets);
+#if (_MT_IS_NEED_LIMIT_SIZE)
+        for (i=0;i<4;++i)
+            disThreads[i]=(times[i]>(minTime/128))?disThreads[i]:0;
+#endif
+        mtsets=*(hpatchMTSets_t*)disThreads;
+    }
+    if ((decompressPlugin!=0)&(mtsets.readDiff_isMT!=0)&(!mtsets.decompressDiff_isMT)){
+        mtsets.readDiff_isMT=0;
+        mtsets.decompressDiff_isMT=1;
+    }
+    return mtsets;
+}
+
+
+typedef struct hpatch_mt_manager_t{
+    struct hpatch_mt_t*     h_mt;
+    hpatch_TStreamOutput*   newData;
+    hpatch_TStreamInput*    oldData;
+    hpatch_TStreamInput*    diffData;
+    hpatch_TStreamInput*    decDiffData;
+} hpatch_mt_manager_t;
+
+static size_t _getObjsMemSize(hpatchMTSets_t mtsets,size_t* pworkBufCount){
+    size_t threadNum=_hpatchMTSets_threadNum(mtsets);
+    size_t objsMemSize=0;
+
+    *pworkBufCount=kObjNodeCount*(threadNum-1);
+    objsMemSize+=_hpatch_align_upper(sizeof(hpatch_mt_manager_t),kAlignSize);
+    objsMemSize+=_hpatch_align_upper(hpatch_mt_t_memSize(threadNum),kAlignSize);
+    objsMemSize+=mtsets.readDiff_isMT       ?_hpatch_align_upper(hinput_mt_t_memSize(),kAlignSize):0;
+    objsMemSize+=mtsets.decompressDiff_isMT ?_hpatch_align_upper(hinput_mt_t_memSize(),kAlignSize):0;
+    objsMemSize+=mtsets.readOld_isMT        ?_hpatch_align_upper(hcache_old_mt_t_memSize(),kAlignSize):0;
+    objsMemSize+=mtsets.writeNew_isMT       ?_hpatch_align_upper(houtput_mt_t_memSize(),kAlignSize):0;
+    return objsMemSize;
+}
+
+
+hpatch_mt_manager_t* hpatch_mt_manager_open(const hpatch_TStreamOutput** pout_newData,
+                                            const hpatch_TStreamInput**  poldData,
+                                            const hpatch_TStreamInput**  psingleCompressedDiff,
+                                            hpatch_StreamPos_t*          pdiffData_pos,
+                                            hpatch_StreamPos_t*          pdiffData_posEnd,
+                                            hpatch_StreamPos_t           uncompressedSize,
+                                            hpatch_TDecompress**         pdecompressPlugin,
+                                            size_t                       stepMemSize,
+                                            hpatch_byte** ptemp_cache,hpatch_byte** ptemp_cache_end,
+                                            sspatch_coversListener_t**   pcoversListener,
+                                            hpatch_BOOL                  isOnStepCoversInThread,
+                                            size_t                       kCacheCount,
+                                            hpatchMTSets_t               mtsets){
+    size_t         objsMemSize;
+    size_t         workBufCount;
+    size_t         workBufNodeSize;
+    size_t         kMinTempCacheSize;
+    hpatch_byte* temp_cache=*ptemp_cache;
+    hpatch_byte* temp_cache_end=*ptemp_cache_end;
+    hpatch_byte* wbufsMem=0;
+    hpatch_size_t workBufSize;
+    hpatch_mt_manager_t* self=0;
+    const size_t threadNum=_hpatchMTSets_threadNum(mtsets);
+    assert(threadNum>1);
+    objsMemSize =_getObjsMemSize(mtsets,&workBufCount);
+    kMinTempCacheSize=objsMemSize+kMinBufNodeSize*(workBufCount+kCacheCount)+(kAlignSize-1);
+    if (stepMemSize+kMinTempCacheSize>(hpatch_size_t)(temp_cache_end-temp_cache)) return 0;
+    if (!mtsets.readOld_isMT){
+        if (_patch_is_can_cache_all_old((*poldData)->streamSize,stepMemSize+kMinTempCacheSize,temp_cache_end-temp_cache)){
+            size_t cacheAllNeedSize=(size_t)_patch_cache_all_old_needSize((*poldData)->streamSize,0);
+            temp_cache_end-=cacheAllNeedSize; // patch_single_stream_diff() will load all old data into memory 
+        }
+    #if (_IS_NEED_CACHE_OLD_BY_COVERS)
+        else{
+            size_t cacheStepNeedSize;
+            kMinTempCacheSize=objsMemSize+kBetterBufNodeSize*(workBufCount+kCacheCount)+(kAlignSize-1);
+            cacheStepNeedSize=_patch_step_cache_old_canUsedSize(stepMemSize,kMinTempCacheSize,temp_cache_end-temp_cache);
+            if (cacheStepNeedSize>0)
+                temp_cache_end-=cacheStepNeedSize; // patch_single_stream_diff() will cache part of old by step
+        }
+    #endif // _IS_NEED_CACHE_OLD_BY_COVERS
+    }
+    {
+        size_t memCacheSize=(temp_cache_end-temp_cache)-objsMemSize-stepMemSize;
+        workBufNodeSize=memCacheSize/(workBufCount+kCacheCount)/kAlignSize*kAlignSize;
+        workBufSize=TWorkBuf_getWorkBufSize(workBufNodeSize);
+    }
+   
+    self=(hpatch_mt_manager_t*)_hpatch_align_upper(temp_cache,kAlignSize);
+    memset(self,0,sizeof(*self));
+    temp_cache=(hpatch_byte*)_hpatch_align_upper(temp_cache+sizeof(hpatch_mt_manager_t),kAlignSize);
+
+    self->h_mt=hpatch_mt_open(temp_cache,hpatch_mt_t_memSize(threadNum),threadNum);
+    if (self->h_mt==0) goto _on_error;
+    temp_cache=(hpatch_byte*)_hpatch_align_upper(temp_cache+hpatch_mt_t_memSize(threadNum),kAlignSize);
+    wbufsMem=temp_cache;
+    temp_cache+=workBufCount*workBufNodeSize;
+    if (mtsets.readDiff_isMT){
+        self->diffData=hinput_mt_open(temp_cache,hinput_mt_t_memSize(),self->h_mt,
+                                      TWorkBuf_allocFreeList(&wbufsMem,kObjNodeCount,workBufNodeSize),workBufSize,
+                                      *psingleCompressedDiff,*pdiffData_pos,*pdiffData_posEnd);
+        if (self->diffData==0) goto _on_error;
+        *psingleCompressedDiff=self->diffData;
+        *pdiffData_posEnd=self->diffData->streamSize;
+        temp_cache=(hpatch_byte*)_hpatch_align_upper(temp_cache+hinput_mt_t_memSize(),kAlignSize);
+    }
+    if (mtsets.decompressDiff_isMT){
+        assert(*pdecompressPlugin);
+        self->decDiffData=hinput_dec_mt_open(temp_cache,hinput_mt_t_memSize(),self->h_mt,
+                                            TWorkBuf_allocFreeList(&wbufsMem,kObjNodeCount,workBufNodeSize),workBufSize,
+                                             self->diffData?self->diffData:*psingleCompressedDiff,*pdiffData_pos,
+                                             self->diffData?self->diffData->streamSize:*pdiffData_posEnd,
+                                             *pdecompressPlugin,uncompressedSize);
+        if (self->decDiffData==0) goto _on_error;
+        *psingleCompressedDiff=self->decDiffData;
+        *pdiffData_posEnd=self->decDiffData->streamSize;
+        *pdecompressPlugin=0;
+        temp_cache=(hpatch_byte*)_hpatch_align_upper(temp_cache+hinput_mt_t_memSize(),kAlignSize);
+    }
+    if (mtsets.readOld_isMT){
+        sspatch_coversListener_t* out_coversListener=0;
+        self->oldData=hcache_old_mt_open(temp_cache,hcache_old_mt_t_memSize(),self->h_mt,
+                                         TWorkBuf_allocFreeList(&wbufsMem,kObjNodeCount,workBufNodeSize),workBufSize,
+                                         *poldData,&out_coversListener,*pcoversListener,isOnStepCoversInThread);
+        if (self->oldData==0) goto _on_error;
+        *poldData=self->oldData;
+        *pcoversListener=out_coversListener;
+        temp_cache=(hpatch_byte*)_hpatch_align_upper(temp_cache+hcache_old_mt_t_memSize(),kAlignSize);
+    }
+    if (mtsets.writeNew_isMT){
+        self->newData=houtput_mt_open(temp_cache,houtput_mt_t_memSize(),self->h_mt,
+                                      TWorkBuf_allocFreeList(&wbufsMem,kObjNodeCount,workBufNodeSize),workBufSize,
+                                      *pout_newData,0);
+        if (self->newData==0) goto _on_error;
+        *pout_newData=self->newData;
+        temp_cache=(hpatch_byte*)_hpatch_align_upper(temp_cache+houtput_mt_t_memSize(),kAlignSize);
+    }
+
+    *ptemp_cache=temp_cache;
+    return self;
+
+_on_error:
+    hpatch_mt_manager_close(self,hpatch_TRUE);
+    return 0;
+}
+
+#define _mt_obj_free(free_fn,mt_obj) { if (mt_obj) { isOnError|=!free_fn(mt_obj); mt_obj=0; } }
+hpatch_BOOL hpatch_mt_manager_close(struct hpatch_mt_manager_t* self,hpatch_BOOL isOnError){
+    if (!self) return !isOnError;
+    if (self->h_mt) hpatch_mt_waitAllThreadEnd(self->h_mt,isOnError);
+    _mt_obj_free(hinput_mt_close,     self->diffData);
+    _mt_obj_free(hinput_mt_close,     self->decDiffData);
+    _mt_obj_free(hcache_old_mt_close, self->oldData);
+    _mt_obj_free(houtput_mt_close,    self->newData);
+    if (self->h_mt) { isOnError|=!hpatch_mt_close(self->h_mt,isOnError); self->h_mt=0; }
+    return !isOnError;
+}
+
+
+#endif //_IS_USED_MULTITHREAD

package/harmony/pushy/src/main/cpp/HDiffPatch/libHDiffPatch/HPatch/hpatch_mt/hpatch_mt.h

@@ -0,0 +1,110 @@
+//  hpatch_mt.h
+//  hpatch
+/*
+ The MIT License (MIT)
+ Copyright (c) 2025 HouSisong
+ 
+ Permission is hereby granted, free of charge, to any person
+ obtaining a copy of this software and associated documentation
+ files (the "Software"), to deal in the Software without
+ restriction, including without limitation the rights to use,
+ copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the
+ Software is furnished to do so, subject to the following
+ conditions:
+ 
+ The above copyright notice and this permission notice shall be
+ included in all copies of the Software.
+ 
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ OTHER DEALINGS IN THE SOFTWARE.
+*/
+#ifndef hpatch_mt_h
+#define hpatch_mt_h
+#include "../patch_types.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct{
+    hpatch_byte     writeNew_isMT;          //0 or 1; if 1, start a thread for write to newData
+    hpatch_byte     readOld_isMT;           //0 or 1; if 1, start a thread for read from oldData
+    hpatch_byte     readDiff_isMT;          //0 or 1; if 1, start a thread for read from diffData
+    hpatch_byte     decompressDiff_isMT;    //0 or 1; if 1, start a thread for decompress diffData
+    //patch func run in main thread
+} hpatchMTSets_t;
+
+static const hpatchMTSets_t hpatchMTSets_no  ={0,0,0,0};
+static const hpatchMTSets_t hpatchMTSets_full={1,1,1,1};
+static hpatch_force_inline
+size_t _hpatchMTSets_threadNum(const hpatchMTSets_t mtsets){
+            return mtsets.writeNew_isMT+mtsets.readOld_isMT+mtsets.readDiff_isMT+mtsets.decompressDiff_isMT+1; }
+
+static hpatch_force_inline 
+hpatchMTSets_t hpatch_getMTSets(hpatch_StreamPos_t newSize,hpatch_StreamPos_t oldSize,hpatch_StreamPos_t diffSize,
+                               const hpatch_TDecompress* decompressPlugin,size_t kCacheCount,size_t stepMemSize,
+                               size_t temp_cacheSumSize,size_t maxThreadNum,hpatchMTSets_t mtsets){
+#if (_IS_USED_MULTITHREAD)
+    hpatchMTSets_t _hpatch_getMTSets(hpatch_StreamPos_t newSize,hpatch_StreamPos_t oldSize,hpatch_StreamPos_t diffSize,
+                                    const hpatch_TDecompress* decompressPlugin,size_t kCacheCount,size_t stepMemSize,
+                                    size_t temp_cacheSumSize,size_t maxThreadNum,hpatchMTSets_t mtsets);
+    if (maxThreadNum<=1) return hpatchMTSets_no;
+    return _hpatch_getMTSets(newSize,oldSize,diffSize,decompressPlugin,kCacheCount,stepMemSize,temp_cacheSumSize,maxThreadNum,mtsets);
+#else
+    return hpatchMTSets_no;
+#endif
+}
+
+
+#define     _kCacheSgCount  3  //patch for singleCompressedDiff need cache count
+hpatch_BOOL _patch_single_stream_mt(sspatch_listener_t* listener,
+                                    const hpatch_TStreamOutput* __out_newData,
+                                    const hpatch_TStreamInput*  oldData,
+                                    const hpatch_TStreamInput*  singleCompressedDiff, 
+                                    hpatch_StreamPos_t  diffInfo_pos,
+                                    sspatch_coversListener_t* coversListener,
+                                    size_t maxThreadNum,hpatchMTSets_t hpatchMTSets);
+hpatch_BOOL _patch_single_compressed_diff_mt(const hpatch_TStreamOutput* out_newData,
+                                             const hpatch_TStreamInput*  oldData,
+                                             const hpatch_TStreamInput*  singleCompressedDiff,
+                                             hpatch_StreamPos_t          diffData_pos,
+                                             hpatch_StreamPos_t          uncompressedSize,
+                                             hpatch_StreamPos_t          compressedSize,
+                                             hpatch_TDecompress*         decompressPlugin,
+                                             hpatch_StreamPos_t coverCount,hpatch_size_t stepMemSize,
+                                             unsigned char* temp_cache,unsigned char* temp_cache_end,
+                                             sspatch_coversListener_t* coversListener,
+                                             size_t maxThreadNum,hpatchMTSets_t mtsets);
+
+#if (_IS_USED_MULTITHREAD)
+
+struct hpatch_mt_manager_t;
+
+struct hpatch_mt_manager_t* hpatch_mt_manager_open(const hpatch_TStreamOutput** pout_newData,
+                                                   const hpatch_TStreamInput**  poldData,
+                                                   const hpatch_TStreamInput**  psingleCompressedDiff,
+                                                   hpatch_StreamPos_t*          pdiffData_pos,
+                                                   hpatch_StreamPos_t*          pdiffData_posEnd,
+                                                   hpatch_StreamPos_t           uncompressedSize,
+                                                   hpatch_TDecompress**         pdecompressPlugin,
+                                                   size_t                       stepMemSize,
+                                                   unsigned char** ptemp_cache,unsigned char** ptemp_cache_end,
+                                                   sspatch_coversListener_t**   pcoversListener,
+                                                   hpatch_BOOL                  isOnStepCoversInThread,
+                                                   size_t                       kCacheCount,
+                                                   hpatchMTSets_t               mtsets);
+
+hpatch_BOOL                 hpatch_mt_manager_close(struct hpatch_mt_manager_t* self,hpatch_BOOL isOnError);
+
+#endif // _IS_USED_MULTITHREAD
+
+#ifdef __cplusplus
+}
+#endif
+#endif //hpatch_mt_h