ok dokey, performance ist ein wenig besser

econ/agents/base_agent.py

@@ -29,7 +29,7 @@ class BaseAgent(ABC):
         """
         Disables agent by removing it from the simulation
         """
-        self.simulation.unregister_agent(id)
+        self.simulation.unregister_agent(self.id)
     def register(self):
         """
         Enables agent by adding it to the simulation:

econ/agents/base_distribution_agent.py

@@ -55,8 +55,7 @@ class Base_Distribution_Agent(BaseAgent,ABC):
 
         if not self.business.inventory[self.resource]>=amount:
             return False # we dont have enough balance
-        if amount>self.max_batch_qty:
-            amount=self.max_batch_qty
+        
         self.business.inventory[self.resource]-=amount
         cx.add_to_account(self.id,self.resource,amount) # prepaid charge account for cx
         order=cx.submit_order(self.id,self.resource,amount,price_per,Side.SELL)

econ/exchange.py

@@ -6,6 +6,7 @@ from influxdb_client import InfluxDBClient, Point
 import time
 import pandas as pd
 import uuid
+import threading
 
 software_start=int(time.time())
 class Exchange():
@@ -30,16 +31,18 @@ class Exchange():
         self.best_ask={}
         self.best_bid={}
         self.total_demand={}
-        self.demand={}
+        #self.demand={}
         self.total_supply={}
-        self.supply={}
+        #self.supply={}
         self.traded_commoditys={}
+        self.lock=threading.Lock()
     
     def add_to_account(self,account_id,resource,amount):
         """
         Adds resources to account escrow
         """
         #check if account exists
+        self.lock.acquire()
         if account_id not in self.account:
             self.account[account_id]={_bal: 0}
         #check if ressource exists
@@ -47,12 +50,14 @@ class Exchange():
             self.account[account_id][resource]=0
         
         self.account[account_id][resource]+=amount
+        self.lock.release()
     
     def remove_from_account(self,account_id,resource,amount) -> int:
         """
         Remove resources from account. Returns amount retrieved
         """
         #check if account exists
+        self.lock.acquire()
         if account_id not in self.account:
             self.account[account_id]={_bal: 0}
         #check if ressource exists
@@ -65,6 +70,7 @@ class Exchange():
             self.account[account_id][resource]=0
         else:
             self.account[account_id][resource]-=amount
+        self.lock.release()
         return ret
 
     def _move_to_escrow(self,account_id,resource,amount):
@@ -133,13 +139,14 @@ class Exchange():
             # no sufficient resources
             return None
         # create order and execude any trades
-        
+        self.lock.acquire()
         order,trades=self.lme.add_order(resource,price,amount,side)
 
         self.orders[order.order_id]=order
         self.order_account_map[order.order_id]=account_id
         self._execute_trades(trades)
         self.calculate_resource_metrics(resource)
+        self.lock.release()
         return order
 
     def cancel_order(self,order_id):
@@ -152,6 +159,7 @@ class Exchange():
         order=self.orders[order_id]
         if self._is_order_complete(order):
             return False
+        self.lock.acquire()
         order=self.lme.cancel_order(order_id,order.instmt)
         
         if order_id in self.order_trades_map: # has order any kind of trades
@@ -171,6 +179,7 @@ class Exchange():
                     qty_traded+=trade.trade_qty
                 qty_diff=qty_submitted-qty_traded
                 self._move_to_account(self.order_account_map[order_id],order.instmt,qty_diff)
+        self.lock.release()
         return True
 
 
@@ -222,21 +231,29 @@ class Exchange():
 
     def calculate_resource_metrics(self, resource):
         order_book = self.lme.order_books.setdefault(resource, OrderBook())
-        best_bid = max(order_book.bids.keys()) if len(order_book.bids) > 0 else None
-        best_ask = max(order_book.asks.keys()) if len(order_book.asks) > 0 else None
+        best_bid = None
+        best_ask = None
         self.total_demand[resource]=0
-        self.demand[resource]={}
+        #self.demand[resource]={}
         for k,v in order_book.bids.items():
-            self.demand[resource][k]=0
+        #    self.demand[resource][k]=0
+            if best_bid==None:
+                best_bid=k
+            if best_bid<=k:
+                best_bid=k
             for o in v:
-                self.demand[resource][k]+=o.leaves_qty
+        #        self.demand[resource][k]+=o.leaves_qty
                 self.total_demand[resource]+=o.leaves_qty
-        self.supply[resource]={}
+        #self.supply[resource]={}
         self.total_supply[resource]=0
         for k,v in order_book.asks.items():
-            self.supply[resource][k]=0
+        #    self.supply[resource][k]=0
+            if best_ask==None:
+                best_ask=k
+            if best_ask<=k:
+                best_ask=k
             for o in v:
-                self.supply[resource][k]+=o.leaves_qty
+        #        self.supply[resource][k]+=o.leaves_qty
                 self.total_supply[resource]+=o.leaves_qty
                 
    

econ/simulation.py

@@ -61,10 +61,15 @@ class Simulation():
         """
         keys=list(self.tick_funcs.keys())
         random.shuffle(keys)
+        tasks=[]
         for k in keys:
             fun=self.tick_funcs[k]
             fun(self.tick_count,self.episode_count)
-        
+        self.taskpool.map(self._execute_tick,tasks)
+
+    def _execute_tick(args):
+        fun=args[0]
+        fun(args[1],args[2])    
 
     def tick(self,episode_length):
         """
@@ -83,13 +88,15 @@ class Simulation():
         busstep=time.time()
         self.tick_count+=1
         self.log_cxs_tick(episode_length)
-        self.log_business_tick(episode_length)
+        #self.log_business_tick(episode_length)
         logstep=time.time()
         self.timings["dss"]+=setup-start
         self.timings["dsa"]+=agentstep-setup
+        self.timings["dsap"]=self.timings["dsa"]/(len(self.tick_funcs)+1)
         self.timings["dab"]+=busstep-agentstep
         self.timings["dbl"]+=logstep-busstep
         self.timings["dt"]+=logstep-start
+        
    
         
 
@@ -98,13 +105,23 @@ class Simulation():
         Resets all agents to new Episode
         """
         self.log_cxs_episode()
+        self.log_business_episode()
         for k,v in self.reset_funcs.items():
             v(self.episode_count)
         for cell_id,cell in self.cells.items():
             cell.setup_supply_for_episode()
+        toclose=[]
         for b in self.businesses:
+            b.tick_episode(self.episode_count)
             if b.balance<=0:
-                self.remove_business(b.id)
+                toclose.append(b.id)
+        for close in toclose:
+            self.remove_business(close)
+        self.timings["numBus"]=len(self.businesses)
+        self.timings["tickfuncs"]=len(self.tick_funcs)
+        self.timings["episode"]=self.episode_count
+        log.PerformanceData.append(self.timings.copy())
+        self.setup_timing(["dss","dsa","dsap","dab","dbl","dt"])
         self.tick_count=0
         self.episode_count+=1
     
@@ -239,7 +256,10 @@ class Simulation():
     def log_business_tick(self,episode_length):
         for bus in self.businesses:
             bus.log(self.episode_count,episode_length,self.tick_count)
-    
+    def log_business_episode(self):
+        for bus in self.businesses:
+            bus.log(self.episode_count,1,0)
+
     def setup_timing(self,metrics):
         for met in metrics:
             self.timings[met]=0