Update benchmarks

Author: =

README.md

@@ -21,6 +21,18 @@ Easy to use , buy may not the best practice for efficiency concern.
 - Nearly all the same with aiomysql (with very limited functions of cource)
 - No automaticly date format transition built-in.
 
+## Performance
+query type | asynchronous multithreading | synchronous multithreading | synchronous single thread
+-|-|-|-
+fast single line query | 4864.96 q/s | 5859.20 q/s | 8209.536 q/s
+fast single line insertion | N/A (todo) | N/A | N/A
+
+*/\* Test platform: \*/*<br>
+*AMD Ryzen 3700x*<br>
+*Windows 10 LTSC*<br>
+*Oracle 19c*<br>
+*You can find performance test codes [here](https://github.com/GoodManWEN/cx_Oracle_async/blob/main/misc).*
+
 ## Example
 ```Python3
 # all_usages.py

cx_Oracle_async/utils.py

@@ -1,6 +1,16 @@
-import asyncio
-import cx_Oracle as csor
 from ThreadPoolExecutorPlus import ThreadPoolExecutor
+import cx_Oracle as csor
+import platform
+import asyncio
+import os
+
+pltfm = platform.system()
+if pltfm == 'Windows':
+    DEFAULT_MAXIMUM_WORKER_NUM = (os.cpu_count() or 1) * 16
+    DEFAULT_MAXIMUM_WORKER_TIMES = 2
+elif pltfm == 'Linux' or pltfm == 'Darwin':
+    DEFAULT_MAXIMUM_WORKER_NUM = (os.cpu_count() or 1) * 32
+    DEFAULT_MAXIMUM_WORKER_TIMES = 3
 
 class AsyncCursorWarpper:
 
@@ -76,10 +86,7 @@ async def __aexit__(self, exc_type, exc, tb):
 class AsyncPoolWarpper:
 
     def __init__(self , pool , loop = None):
-
-        def _test():
-            ...
-
+        
         if loop == None:
             loop = asyncio.get_running_loop()
         '''
@@ -90,7 +97,8 @@ def _test():
 
         Issue if you have better implementation.
         '''
-        self._thread_pool = ThreadPoolExecutor() 
+        self._thread_pool = ThreadPoolExecutor(max_workers = max(DEFAULT_MAXIMUM_WORKER_NUM , pool.max << DEFAULT_MAXIMUM_WORKER_TIMES)) 
+        self._thread_pool.set_daemon_opts(min_workers = max(4 , pool.min << 1))
         self._loop = loop 
         self._pool = pool 
 
@@ -104,7 +112,6 @@ def _test():
 
         await self._loop.run_in_executor(self._thread_pool , _test)
 
-
 async def create_pool(host = 'localhost', port = '1521' , user = 'sys', password = '', db = 'orcl', loop = None, minsize = 2 , maxsize = 4 , encoding = 'UTF-8' , autocommit=False):
     if loop == None:
         loop = asyncio.get_running_loop()

misc/performance_test_asynchronous.py

@@ -0,0 +1,53 @@
+class Counter:
+
+    def __init__(self):
+        self.success = 0
+        self.fail = 0
+
+async def single_thread_fetching(oracle_pool , counter):
+    SQL = "SELECT DEPTNO FROM SCOTT.DEPT WHERE DEPTNO = 10"
+    async with oracle_pool.acquire() as connection:
+        async with connection.cursor() as cursor:
+            while True:
+                await cursor.execute(SQL)
+                r = await cursor.fetchone()
+                if r and r[0] == 10:
+                    counter.success += 1
+                else:
+                    counter.fail += 1
+
+async def report_thread(counter , oracle_pool):
+    st_time =  time.time()
+    while True:
+        await asyncio.sleep(2)
+        time_passed  = time.time() - st_time
+        print(f"Report every 2 secs : [success] {counter.success} \t[fail] {counter.fail} \t[qps] {'%.2f' % round(counter.success / time_passed , 2)} \t[time_passed] {'%.2f' % round(time_passed,2)}s")
+
+async def main():
+    loop = asyncio.get_running_loop()
+    oracle_pool = await cx_Oracle_async.create_pool( 
+                                host='localhost', 
+                                port='1521',
+                                user='system', 
+                                password='123456',
+                                db='orcl', 
+                                loop=loop,
+                                autocommit=False,
+                                minsize = 2,
+                                maxsize = THREAD_NUM,
+                        )
+    counter = Counter()
+    loop = asyncio.get_running_loop()
+    for _ in range(THREAD_NUM):
+        loop.create_task(single_thread_fetching(oracle_pool , counter))
+    loop.create_task(report_thread(counter , oracle_pool))
+    while True:
+        await asyncio.sleep(3600)
+
+if __name__ == '__main__':
+    import asyncio
+    import cx_Oracle_async
+    import time
+    import os
+    THREAD_NUM = (os.cpu_count() or 1) << 2
+    asyncio.run(main())

misc/performance_test_synchronous.py

@@ -0,0 +1,35 @@
+from concurrent.futures import ThreadPoolExecutor
+import cx_Oracle
+import os
+import time
+
+class Counter:
+
+    def __init__(self , num):
+        self.success = [0 for _ in range(num)]
+        self.fail = [0 for _ in range(num)]
+
+def single_thread(pool , counter , _id):
+    SQL = "SELECT DEPTNO FROM SCOTT.DEPT WHERE DEPTNO = 10"
+    connection = pool.acquire()
+    cursor = connection.cursor()
+    while True:
+        cursor.execute(SQL)
+        r = cursor.fetchone()
+        if r and r[0] == 10:
+            counter.success[_id] += 1
+        else:
+            counter.fail[_id] += 1
+        # break
+
+THREAD_NUM = (os.cpu_count() or 1) << 1
+pool = cx_Oracle.SessionPool("system", "123456", "localhost:1521/orcl" , min =1 , max = 4 , increment = 1 , threaded = True , encoding = 'UTF-8')
+counter = Counter(THREAD_NUM)
+with ThreadPoolExecutor(max_workers = THREAD_NUM << 5) as executor:
+    for _ in range(THREAD_NUM):
+        executor.submit(single_thread , pool , counter , _)
+    st_time = time.time()
+    while True:
+        time.sleep(2)
+        time_passed = time.time() - st_time
+        print(f"Report every 2 secs : [success] {sum(counter.success)} \t[fail] {sum(counter.fail)} \t[qps] {'%.2f' % round(sum(counter.success) / time_passed , 2)} \t[time_passed] {'%.2f' % round(time_passed,2)}s")