ok dokey, performance ist ein wenig besser

db/demand-tags.yml

@@ -4,4 +4,3 @@ spec:
     res:
       - 'Food': 1
       - 'Fruit': 0.1
-      - 'Fuel': 0.1

db/production.yml

@@ -6,7 +6,7 @@ spec:
     prod:
       - Raw_Agriculture_Plot: 1
   - name: Fruit
-    amount: 10
+    amount: 75
     prod:
       - Raw_Agriculture_Plot: 1
   - name: Wood
@@ -20,7 +20,7 @@ spec:
       - Wood: 1
 
   - name: Food
-    amount: 5
+    amount: 10
     prod:
       - Fuel: 1
       - Fruit: 1

db/world-tags.yml

@@ -6,12 +6,12 @@ spec:
 
   - name: grass
     res:
-      - 'Raw_Agriculture_Plot': 1
+      - 'Raw_Agriculture_Plot': 0.5
-      - 'Raw_Forrest': 1
+      - 'Raw_Forrest': 0.5
 
   - name: forrest
     res:
-      - 'Raw_Agriculture_Plot': 1
+      - 'Raw_Agriculture_Plot': 0.5
-      - 'Raw_Forrest': 2
+      - 'Raw_Forrest': 0.5
 
   

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_bid = None
-        best_ask = max(order_book.asks.keys()) if len(order_book.asks) > 0 else 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,28 +88,40 @@ 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
         
    
         
+
     def reset(self):
         """
         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,6 +256,9 @@ 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:

log/__init__.py

@@ -16,6 +16,7 @@ EXInit=False
 EXBooksData=[]
 EXTradeData=[]
 BUSINESSData=[]
+PerformanceData=[]
 def get_client():
     global write_client
     if write_client==None:
@@ -43,3 +44,13 @@ def writeBusinessData():
     df.to_sql('business', con=db, if_exists='replace',
           index=False,chunksize=10000)
     print(f"business completed: {df.size}")
+def writePerformanceData():
+    db = create_engine(posturl)
+    df=pd.DataFrame(PerformanceData)
+    df.to_sql('performance', con=db, if_exists='replace',
+          index=False,chunksize=10000)
+    print(f"performance completed: {df.size}")
+def clearlog():
+    EXBooksData=[]
+    EXTradeData=[]
+    BUSINESSData=[]

main.py

@@ -29,20 +29,25 @@ cxs=[cx]
 #cx.submit_order(2,"Gem",1,10,Side.SELL)
 
 sim=Simulation()
-sim.seed(55)
+sim.seed(42)
-sim.set_cells(cells[:10])
+sim.set_cells(cells)
 sim.reset()
 #sim.tick(1)
 # create info
-while len(sim.get_underutelized_prods(2))>0:
+while len(sim.get_underutelized_prods(5))>0:
-    sim.create_bussiness(2)
+    sim.create_bussiness(5)
 #sim.reset()
 for a in tqdm(range(50)):
     for i in range(100):
         sim.tick(100)
+    print(f"|Stats| Num of Businesses: {len(sim.businesses)} Num Tickfunk: {len(sim.tick_funcs)} Time Agent Tick: {sim.timings['dsa']} Time Logging {sim.timings['dbl']}")
     sim.reset()
-    sim.create_bussiness(2)
+    sim.create_bussiness(3)
+   
+    
+
 log.writeEXData()
 log.writeBusinessData()
+log.writePerformanceData()
 
 print("help")