react-native-update 10.34.3 → 10.34.4

package/harmony/pushy/src/main/cpp/HDiffPatch/libParallel/parallel_channel.cpp

@@ -42,11 +42,12 @@ public:
     ~_CChannel_import(){
         close();
         while (true) { //wait all thread exit
+            if (_waitingCount==0) break;
             {
                 CAutoLocker locker(_locker);
                 if (_waitingCount==0) break;
             }
-            this_thread_yield(); //optimize?
+            this_thread_yield(); //todo:优化?
         }
         locker_delete(_locker);
         assert(_dataList.empty()); // why? if saved resource then leaks
@@ -66,6 +67,7 @@ public:
     bool is_can_fast_send(bool isWait){
         if (_maxDataCount<0) return true;
         if (_maxDataCount==0) return false;
+        if (_isClosed) return false;
 
         CAutoLocker locker(_locker);
         while (true) {
@@ -83,6 +85,7 @@ public:
 
     bool send(TChanData data,bool isWait){
         assert(data!=0);
+        if (_isClosed) return false;
         {
             CAutoLocker locker(_locker);
             while (true) {
@@ -109,12 +112,13 @@ public:
 
         //wait accepted
         while (true) { //wait _dataList empty
+            if (_isClosed) break;
             {
                 CAutoLocker locker(_locker);
                 if (_isClosed) break;
                 if (_dataList.empty()) break;
             }
-            this_thread_yield(); //optimize?
+            this_thread_yield(); //todo:优化;
         }
         return true;
     }

package/harmony/pushy/src/main/cpp/HDiffPatch/libParallel/parallel_channel.h

@@ -29,16 +29,8 @@
 #define parallel_channel_h
 #include "parallel_import.h"
 #if (_IS_USED_MULTITHREAD)
-#include <stdint.h> //uint32_t uint64_t
-#include <assert.h>
-#include <stddef.h> //for size_t ptrdiff_t
 
-#ifndef _IS_USED_CPP_ATOMIC
-#   define  _IS_USED_CPP_ATOMIC     1
-#endif
-#if (_IS_USED_CPP_ATOMIC)
-#   include <atomic>
-#endif
+#include <stddef.h> //for size_t ptrdiff_t
 
 struct CHLocker{
     HLocker locker;
@@ -46,98 +38,25 @@ struct CHLocker{
     inline ~CHLocker() { locker_delete(locker); }
 };
 
-struct CAutoLocker{
-    inline explicit CAutoLocker(HLocker _locker){ locker=_locker; if (locker) locker_enter(locker); }
-    inline explicit CAutoLocker(CHLocker& _locker){ locker=_locker.locker; if (locker) locker_enter(locker); }
-    inline ~CAutoLocker(){ if (locker) locker_leave(locker); }
-    HLocker locker;
-};
-hpatch_force_inline static
-void        condvar_wait(HCondvar cond,CAutoLocker* locker) { condvar_wait_at(cond,locker->locker); }
-
-#if ((_IS_USED_CPP_ATOMIC) && (!_IS_NO_ATOMIC_U64))
-    class CWaitValueByAtomic{
-    public:
-        inline explicit CWaitValueByAtomic(uint64_t initValue=0) : _value(initValue) {}
-        inline void     store(uint64_t value) { _value.store(value); }
-        inline uint64_t load() const { return _value.load(); }
-        template<class TFailFunc,class TFailImport>
-        bool wait(uint64_t value,TFailFunc failWaitCallBackFunc,const TFailImport* failWaitImport){
-            while (true){
-                if (_value.load()==value) return true;
-                this_thread_yield();
-                if (failWaitCallBackFunc(failWaitImport)) return false;
-            }
-        }
-    private:
-        volatile std::atomic<uint64_t>  _value;
-    };
-#endif
-
-    class CWaitValueByLocker{ //CWaitValueByLocker
-    public:
-        inline explicit CWaitValueByLocker(uint64_t initValue=0):_value(initValue) {}
-        inline void     store(uint64_t value) { CAutoLocker _autoLocker(_locker.locker); _value=value; }
-        inline uint64_t load() const { CAutoLocker _autoLocker(_locker.locker); return _value; }
-        template<class TFailFunc,class TFailImport>
-        bool wait(uint64_t value,TFailFunc failWaitCallBackFunc,const TFailImport* failWaitImport){
-            while (true){
-                {
-                    CAutoLocker _autoLocker(_locker.locker);
-                    if (_value==value) return true;
-                }
-                this_thread_yield();
-                if (failWaitCallBackFunc(failWaitImport)) return false;
-            }
-        }
-    private:
-        CHLocker            _locker;
-        volatile uint64_t   _value;
-    };
-
-    class CWaitValueByCondvar{ //CWaitValueByCondvar
-    public:
-        inline explicit CWaitValueByCondvar(uint64_t initValue=0):_value(initValue),_condvar(0){
-            _condvar=condvar_new();
-        }
-        inline ~CWaitValueByCondvar(){ condvar_delete(_condvar); }
-        inline void     store(uint64_t value){
-            CAutoLocker _autoLocker(_locker.locker);
-            if (_value==value) return; //no need notify
-            _value=value;
-            condvar_broadcast(_condvar);
-        }
-        inline uint64_t load(){
-            CAutoLocker _autoLocker(_locker.locker);
-            return _value;
-        }
-        template<class TFailFunc,class TFailImport>
-        bool wait(uint64_t expectedValue,TFailFunc failWaitCallBackFunc,const TFailImport* failWaitImport){
-            while (true){
-                {
-                    CAutoLocker _autoLocker(_locker.locker);
-                    if (_value==expectedValue) return true;
-                    condvar_wait(_condvar,&_autoLocker);
-                    if (_value==expectedValue) return true;
-                }
-                if (failWaitCallBackFunc(failWaitImport)) return false;
-            }
-        }
-    private:
-        volatile uint64_t   _value;
-        CHLocker            _locker;
-        HCondvar            _condvar;
+#if (_IS_USED_CPP11THREAD)
+#   include <mutex>
+    struct CAutoLocker:public _TLockerBox_name {
+        inline CAutoLocker(HLocker _locker)
+            :_TLockerBox_name(*(std::mutex*)_locker){ }
+        inline ~CAutoLocker(){ }
     };
-
-// CWaitValue: thread waits for a value before it can continue;
-#if ((_IS_USED_CPP_ATOMIC) && (!_IS_NO_ATOMIC_U64))
-    typedef CWaitValueByAtomic CWaitValue;
 #else
-    typedef CWaitValueByLocker CWaitValue; 
+    struct CAutoLocker:public TLockerBox {
+        inline CAutoLocker(HLocker _locker){ locker=_locker; locker_enter(locker); }
+        inline ~CAutoLocker(){ locker_leave(locker); }
+    };
 #endif
 
+    //通道交互数据;
+    typedef void* TChanData;
+
     class _CChannel_import;
-    //Channel;
+    //通道;
     class CChannel{
     public:
         explicit CChannel(ptrdiff_t maxDataCount=-1);
@@ -150,101 +69,5 @@ void        condvar_wait(HCondvar cond,CAutoLocker* locker) { condvar_wait_at(co
         _CChannel_import* _import;
     };
 
-//Share data via channel passing;
-struct TMtByChannel {
-    CChannel read_chan;
-    CChannel work_chan;
-    CChannel data_chan;
-
-    void on_error(){
-        {
-        #if (_IS_USED_CPP_ATOMIC)
-            if (_is_on_error.load()) return;
-            _is_on_error.store(true);
-        #else
-            CAutoLocker _auto_locker(_locker.locker);
-            if (_is_on_error) return;
-            _is_on_error=true;
-        #endif
-        }
-        closeAndClear();
-    }
-    
-    bool start_threads(int threadCount,TThreadRunCallBackProc threadProc,void* workData,bool isUseThisThread){
-        for (int i=0;i<threadCount;++i){
-            if (isUseThisThread&&(i==threadCount-1)){
-                thread_on(1);
-                threadProc(i,workData);
-            }else{
-                thread_on(1);
-                try{
-                    thread_parallel(1,threadProc,workData,0,i);
-                }catch(...){
-                    thread_on(-1);
-                    on_error();
-                    return false;
-                }
-            }
-        }
-        return true;
-    }
-    inline void thread_end(){
-        _end_chan.send((TChanData)1,true);
-    }
-    struct TAutoThreadEnd{
-        inline  explicit TAutoThreadEnd(TMtByChannel& mt) :_mt(mt) {  }
-        inline ~TAutoThreadEnd() { _mt.thread_end(); }
-        TMtByChannel&  _mt;
-    };
-
-    inline  explicit TMtByChannel():_is_on_error(false),_is_thread_on(0) {}
-    inline ~TMtByChannel() { closeAndClear(); wait_all_thread_end(); _end_chan.close(); while (_end_chan.accept(false)) {} }
-    inline bool is_on_error()const{ 
-        #if (_IS_USED_CPP_ATOMIC)
-            return _is_on_error.load();
-        #else
-            CAutoLocker _auto_locker(_locker.locker);
-            return _is_on_error;
-        #endif
-        }
-    inline static bool is_on_error_by(const TMtByChannel* mt){ return mt->is_on_error(); }
-    
-    inline void finish(){ // stop & wait all threads exit
-        close();
-        wait_all_thread_end();
-    }
-    inline void wait_all_thread_end(){
-        while(_is_thread_on){
-            --_is_thread_on;
-            _end_chan.accept(true);
-        }
-    }
-protected:
-    CHLocker  _locker;
-#if (_IS_USED_CPP_ATOMIC)
-    volatile std::atomic<bool> _is_on_error;
-#else
-    volatile bool _is_on_error;
-#endif
-    
-    inline void close() {
-        read_chan.close();
-        work_chan.close();
-        data_chan.close();
-    }
-    void closeAndClear(){
-        close();
-        while(read_chan.accept(false)) {}
-        while(work_chan.accept(false)) {}
-        while(data_chan.accept(false)) {}
-    }
-private:
-    inline void thread_on(int threadNum){
-        _is_thread_on+=threadNum;
-    }
-    volatile size_t _is_thread_on;
-    CChannel  _end_chan;
-};
-
 #endif //_IS_USED_MULTITHREAD
 #endif //parallel_channel_h

package/harmony/pushy/src/main/cpp/HDiffPatch/libParallel/parallel_import.cpp

@@ -0,0 +1,367 @@
+//  parallel_import.cpp
+/*
+ The MIT License (MIT)
+ Copyright (c) 2018 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 "parallel_import.h"
+#include <assert.h>
+
+#if (_IS_USED_PTHREAD)
+#   ifdef WIN32
+#       include "windows.h" //for Sleep
+#       //pragma comment(lib,"pthread.lib") //for static pthread lib
+#       //define PTW32_STATIC_LIB  //for static pthread lib
+#   endif
+#   include <pthread.h>
+#   ifdef __ANDROID__
+#       include <sched.h> // sched_yield()
+#   endif
+#endif
+#if (_IS_USED_CPP11THREAD)
+#   include <thread>
+#   include <mutex>
+#   include <condition_variable>
+#endif
+#if (_IS_USED_WIN32THREAD)
+#   include "windows.h"
+#   ifndef UNDER_CE
+#       include "process.h"
+#   endif
+#endif
+
+#if (_IS_USED_PTHREAD)
+#include <string.h> //for memset
+#include <stdlib.h>
+#include <stdexcept>
+#include <string>
+#include <stdio.h>
+
+static std::string _i2a(int ivalue){
+    const int kMaxNumCharSize =32;
+    std::string result;
+    result.resize(kMaxNumCharSize);
+#ifdef _MSC_VER
+    int len=sprintf_s(&result[0],kMaxNumCharSize,"%d",ivalue);
+#else
+    int len=sprintf(&result[0],"%d",ivalue);
+#endif
+    result.resize(len);
+    return result;
+}
+#define _check_pthread(result,func_name) { \
+    if (result!=0) throw std::runtime_error(func_name "() return "+_i2a(result)+" error!"); }
+
+HLocker locker_new(void){
+    pthread_mutex_t* self=new pthread_mutex_t();
+    int rt=pthread_mutex_init(self, 0);
+    if (rt!=0){
+        delete self;
+        _check_pthread(rt,"pthread_mutex_init");
+    }
+    return  self;
+}
+void locker_delete(HLocker locker){
+    if (locker!=0){
+        pthread_mutex_t* self=(pthread_mutex_t*)locker;
+        int rt=pthread_mutex_destroy(self);
+        delete self;
+        _check_pthread(rt,"pthread_mutex_destroy");
+    }
+}
+
+void locker_enter(HLocker locker){
+    pthread_mutex_t* self=(pthread_mutex_t*)locker;
+    int rt=pthread_mutex_lock(self);
+    _check_pthread(rt,"pthread_mutex_lock");
+}
+void locker_leave(HLocker locker){
+    pthread_mutex_t* self=(pthread_mutex_t*)locker;
+    int rt=pthread_mutex_unlock(self);
+    _check_pthread(rt,"pthread_mutex_unlock");
+}
+
+HCondvar condvar_new(void){
+    pthread_cond_t* self=new pthread_cond_t();
+    int rt=pthread_cond_init(self,0);
+    if (rt!=0){
+        delete self;
+        _check_pthread(rt,"pthread_cond_init");
+    }
+    return self;
+}
+void    condvar_delete(HCondvar cond){
+    if (cond){
+        pthread_cond_t* self=(pthread_cond_t*)cond;
+        int rt=pthread_cond_destroy(self);
+        delete self;
+        _check_pthread(rt,"pthread_cond_destroy");
+    }
+}
+void    condvar_wait(HCondvar cond,TLockerBox* lockerBox){
+    pthread_cond_t* self=(pthread_cond_t*)cond;
+    int rt=pthread_cond_wait(self,(pthread_mutex_t*)(lockerBox->locker));
+    _check_pthread(rt,"pthread_cond_wait");
+}
+void    condvar_signal(HCondvar cond){
+    pthread_cond_t* self=(pthread_cond_t*)cond;
+    int rt=pthread_cond_signal(self);
+    _check_pthread(rt,"pthread_cond_signal");
+}
+void    condvar_broadcast(HCondvar cond){
+    pthread_cond_t* self=(pthread_cond_t*)cond;
+    int rt=pthread_cond_broadcast(self);
+    _check_pthread(rt,"pthread_cond_broadcast");
+}
+
+void this_thread_yield(){
+#ifdef __APPLE__
+    pthread_yield_np();
+#else
+#   ifdef WIN32
+    Sleep(0);
+#   else
+#       ifdef __ANDROID__
+            sched_yield();
+#       else
+            pthread_yield();
+#       endif
+#   endif
+#endif
+}
+
+struct _TThreadData{
+    TThreadRunCallBackProc  threadProc;
+    int                     threadIndex;
+    void*                   workData;
+};
+static void* _pt_threadProc(void* _pt){
+    _TThreadData* pt=(_TThreadData*)_pt;
+    pt->threadProc(pt->threadIndex,pt->workData);
+    delete pt;
+    return 0;
+}
+
+void thread_parallel(int threadCount,TThreadRunCallBackProc threadProc,void* workData,
+                     int isUseThisThread,int threadIndexStart){
+    for (int i=0; i<threadCount; ++i) {
+        if ((i==threadCount-1)&&(isUseThisThread)){
+            threadProc(i+threadIndexStart,workData);
+        }else{
+            _TThreadData* pt=new _TThreadData();
+            pt->threadIndex=i+threadIndexStart;
+            pt->threadProc=threadProc;
+            pt->workData=workData;
+            pthread_t t; memset(&t,0,sizeof(pthread_t));
+            int rt=pthread_create(&t,0,_pt_threadProc,pt);
+            if (rt!=0){
+                delete pt;
+                _check_pthread(rt,"pthread_create");
+            }
+            rt=pthread_detach(t);
+            _check_pthread(rt,"pthread_detach");
+        }
+    }
+}
+#endif //_IS_USED_PTHREAD
+
+#if (_IS_USED_CPP11THREAD)
+HLocker locker_new(void){
+    return new std::mutex();
+}
+void locker_delete(HLocker locker){
+    if (locker!=0)
+        delete (std::mutex*)locker;
+}
+
+void locker_enter(HLocker locker){
+    std::mutex* self=(std::mutex*)locker;
+    self->lock();
+    
+}
+void locker_leave(HLocker locker){
+    std::mutex* self=(std::mutex*)locker;
+    self->unlock();
+}
+
+HCondvar condvar_new(void){
+    std::condition_variable* self=new std::condition_variable();
+    return self;
+} 
+void    condvar_delete(HCondvar cond){
+    if (cond){
+        std::condition_variable* self=(std::condition_variable*)cond;
+        delete self;
+    }
+}
+void    condvar_wait(HCondvar cond,TLockerBox* locker){
+    std::condition_variable* self=(std::condition_variable*)cond;
+    _TLockerBox_name* _locker=(_TLockerBox_name*)locker;
+    self->wait(*_locker);
+}
+void    condvar_signal(HCondvar cond){
+    std::condition_variable* self=(std::condition_variable*)cond;
+    self->notify_one();
+}
+void    condvar_broadcast(HCondvar cond){
+    std::condition_variable* self=(std::condition_variable*)cond;
+    self->notify_all();
+}
+
+void this_thread_yield(){
+    std::this_thread::yield();
+}
+
+
+struct _TThreadProc{
+    TThreadRunCallBackProc threadProc;
+    int   threadIndex;
+    void* workData;
+    inline void operator()(){  threadProc(threadIndex,workData);  }
+};
+void thread_parallel(int threadCount,TThreadRunCallBackProc threadProc,void* workData,
+                     int isUseThisThread,int threadIndexStart){
+    for (int i=0; i<threadCount; ++i) {
+        if ((i==threadCount-1)&&(isUseThisThread)){
+            threadProc(i+threadIndexStart,workData);
+        }else{
+            _TThreadProc tp={threadProc,i+threadIndexStart,workData};
+            std::thread t(tp);
+            t.detach();
+        }
+    }
+}
+#endif //_IS_USED_CPP11THREAD
+
+
+#if (_IS_USED_WIN32THREAD)
+#include <string.h> //for memset
+#include <stdlib.h>
+#include <stdexcept>
+#include <string>
+#include <stdio.h>
+
+#define _check(value,func_name) { \
+    if (!(value)) throw std::runtime_error(func_name "() run error!"); }
+
+
+HLocker locker_new(void){
+    CRITICAL_SECTION* self=new CRITICAL_SECTION();
+    InitializeCriticalSection(self);
+    return  self;
+}
+void locker_delete(HLocker locker){
+    if (locker!=0){
+        CRITICAL_SECTION* self=(CRITICAL_SECTION*)locker;
+        DeleteCriticalSection(self);
+        delete self;
+    }
+}
+
+void locker_enter(HLocker locker){
+    CRITICAL_SECTION* self=(CRITICAL_SECTION*)locker;
+    EnterCriticalSection(self);
+}
+void locker_leave(HLocker locker){
+    CRITICAL_SECTION* self=(CRITICAL_SECTION*)locker;
+    LeaveCriticalSection(self);
+}
+
+HCondvar condvar_new(void){
+    CONDITION_VARIABLE* self=new CONDITION_VARIABLE();
+    InitializeConditionVariable(self);
+    return self;
+}
+void    condvar_delete(HCondvar cond){
+    if (cond){
+        CONDITION_VARIABLE* self=(CONDITION_VARIABLE*)cond;
+        delete self;
+    }
+}
+void    condvar_wait(HCondvar cond,TLockerBox* lockerBox){
+    CONDITION_VARIABLE* self=(CONDITION_VARIABLE*)cond;
+    BOOL rt=SleepConditionVariableCS(self,(CRITICAL_SECTION*)(lockerBox->locker),INFINITE);
+    _check(rt,"SleepConditionVariableCS");
+}
+void    condvar_signal(HCondvar cond){
+    CONDITION_VARIABLE* self=(CONDITION_VARIABLE*)cond;
+    WakeConditionVariable(self);
+}
+void    condvar_broadcast(HCondvar cond){
+    CONDITION_VARIABLE* self=(CONDITION_VARIABLE*)cond;
+    WakeAllConditionVariable(self);
+}
+
+void this_thread_yield(){
+    Sleep(0);
+}
+
+struct _TThreadData{
+    TThreadRunCallBackProc  threadProc;
+    int                     threadIndex;
+    void*                   workData;
+};
+
+#ifdef UNDER_CE
+    static DWORD WINAPI _win_threadProc(void* _pt){
+#else
+    static unsigned int WINAPI _win_threadProc(void* _pt){
+#endif
+        _TThreadData* pt=(_TThreadData*)_pt;
+        pt->threadProc(pt->threadIndex,pt->workData);
+        delete pt;
+        return 0;
+    }
+
+template <class TProc>
+inline static HANDLE _thread_create(TProc func,void* param){
+#ifdef UNDER_CE
+    DWORD threadId;
+    return CreateThread(0,0,func,param,0,&threadId);
+#else
+    unsigned threadId;
+    return (HANDLE)_beginthreadex(0,0,func,param,0,&threadId);
+#endif
+}
+
+void thread_parallel(int threadCount,TThreadRunCallBackProc threadProc,void* workData,
+                     int isUseThisThread,int threadIndexStart){
+    for (int i=0; i<threadCount; ++i) {
+        if ((i==threadCount-1)&&(isUseThisThread)){
+            threadProc(i+threadIndexStart,workData);
+        }else{
+            _TThreadData* pt=new _TThreadData();
+            pt->threadIndex=i+threadIndexStart;
+            pt->threadProc=threadProc;
+            pt->workData=workData;
+            HANDLE rt=_thread_create(_win_threadProc,pt);
+            if (rt==0){
+                delete pt;
+                _check(rt!=0,"_thread_create");
+            } else {
+                CloseHandle(rt);    
+            }
+        }
+    }
+}
+#endif //_IS_USED_WIN32THREAD