To address the memory issue Alexander is facing with the SPXW weekly options backtesting, here are some suggestions based on best practices and potential optimizations:

1. Optimize Data Resolution: Consider reducing the data resolution from hourly to daily. This can significantly decrease the amount of data processed and reduce memory usage.

2. Limit Option Chains: Implement a more restrictive filter on the option chains to limit the number of contracts loaded into memory. You can narrow the strike range or expiration window further. For example, you might consider filtering for options that are closer to the money or have shorter expiration periods.

3. Use Lean Data: Utilize Lean data normalization and compression techniques to minimize memory consumption during backtesting. Ensure that you are only requesting the data you need.

4. Monitor Memory Usage: Add logging to monitor memory usage throughout the backtest to identify specific points where memory spikes occur. This can help pinpoint the operations that are consuming the most memory.

5. Incremental Backtesting: Break down the backtesting period into smaller segments and run them incrementally. This approach can help manage memory usage more effectively by processing smaller chunks of data at a time.

6. Upgrade Resources: If possible, consider upgrading the backtesting node to a higher memory capacity to accommodate the large dataset being processed.

Here's an updated version of the code with some of these optimizations:

from AlgorithmImports import *
class WeeklyPuts(QCAlgorithm):
    def initialize(self):
        self.set_start_date(2012, 1, 2) 
        self.set_end_date(2024, 12, 12)  
        self.set_cash(1_000_000)
        self.resolution = Resolution.DAILY  # Changed to daily resolution
        self.index = self.add_index('SPX', resolution=self.resolution)
        self.index_symbol = self.index.symbol
        self.spxw_option = self.add_index_option(self.index_symbol, "SPXW", resolution=self.resolution)
        self.spxw_option.set_filter(self.spxw_filter)
        self.spxw_symbol = self.spxw_option.symbol
    def spxw_filter(self, universe: OptionFilterUniverse) -> OptionFilterUniverse:
        # Narrowing the strike range and expiration window
        return universe.weeklys_only().strikes(-1, 1).puts_only().expiration(0, 5)
    def on_data(self, data: Slice):
        spxw_chain = data.option_chains.get(self.spxw_symbol)
        if spxw_chain is None or len(spxw_chain.contracts) == 0:
            return
+ Expand
- Collapse

By implementing these changes, you should see an improvement in memory usage and potentially resolve the errors you are encountering.

Sources: Option Expiration Week Effect, Basic Template S P X Weekly Index Options Algorithm, Asset Growth Effect, Upcoming Holiday Momentum for Amazon, Basic Template Index Options Algorithm

The memory consumption is pretty much the same even if I use daily data 

Hi Alexander

You may try the following optimization:

1. You don't need the SPX index subscription to trade SPXW options.
2. Just subscribe to the option contract you need but not the whole chain.

class WeeklyPuts(QCAlgorithm):
    def initialize(self):
        self.set_start_date(2012, 1, 2) 
        self.set_end_date(2024, 12, 12)
        self.set_cash(1_000_000)
        
        self.spx = self.add_index("SPX")
    def on_data(self, slice):
        spxw = Symbol.create_canonical_option(self.spx.symbol, "SPXW", None, None)
        spxw_chain = list(self.option_chains(spxw).values())
        if spxw_chain:
            filtered_chain = [self.add_option_contract(x).symbol for x in spxw_chain[0] \
                if self.spx.price - 10 <= x.strike <= self.spx.price + 10\
                and x.expiry <= self.time + timedelta(1)\
                and x.right == OptionRight.PUT
            ]
+ Expand
- Collapse

Best
Louis