Backtest wait too long

class SellCallWeekkly(QCAlgorithm):
    def initialize(self):
        self.set_start_date(2022, 2, 1)
        self.set_end_date(2022, 3, 30)
        self.set_cash(10000000000) 
        self.set_name("Sell Call Strategy")
        self.equity = self.add_equity("APPL", Resolution.HOUR)
        self.option = self.add_option("APPL", Resolution.HOUR)
        self.option.set_filter(self.universe_func)
        chart = Chart("Stock Info Chart")
        chart.add_series(Series("Price", SeriesType.LINE, 0))
        self.add_chart(chart)

    def universe_func(self, universe):
        return universe.include_weeklys().calls_only().expiration(0, 10)

    def get_holding_option(self):
        holding_options = []
        for kvp in self.portfolio.securities:
            security = kvp.value
            if security.type == SecurityType.OPTION and security.holdings.quantity != 0:
                symbol = security.Symbol
                quantity = security.holdings.quantity
                holding_options.append(security)
        return holding_options

    def get_holding_stock(self):
        holding_stocks = []
        for kvp in self.portfolio.securities:
            security = kvp.value
            if security.type == SecurityType.EQUITY and security.holdings.quantity != 0:
                symbol = security.Symbol
                quantity = security.holdings.quantity
                holding_stocks.append(security)
        return holding_stocks

    def get_target_strike_price_option(self, slice, traget_strike_price):
        target_strike = traget_strike_price
        chain_value = slice.option_chains[self.option.Symbol]
        contracts = sorted(chain_value.contracts.values, 
                           key=lambda x: (abs(x.strike - target_strike), -x.Expiry.timestamp()))
        selected_contract = contracts[0]
        return selected_contract

    def sell_option_at_115price(self, slice):
        stock_price = self.securities[self.equity.Symbol].price
        target_strike = stock_price * 1.15
        contract = self.get_target_strike_price_option(slice, target_strike)
        quantity = 10 
        self.market_order(contract.Symbol, -quantity)

    def sell_on_monday(self, slice):
        if self.time.weekday() != 0:
            return
        self.liquidate(self.equity.Symbol)
        self.sell_option_at_115price(slice)

    def check_to_buy_back(self, slice, hodling_options, holding_stocks):
        stock_price = self.securities[self.equity.Symbol].price
        option_security = hodling_options[0]
        symbol = option_security.Symbol
        strike_price = symbol.id.strike_price
        if stock_price <= strike_price:
            return
        self.debug(f"stock_price{stock_price},strike_price{strike_price}")
        if len(holding_stocks) == 0:
            self.debug(f"buy stock {option_security.holdings.quantity}") 
            self.market_order(self.equity.Symbol, abs(option_security.holdings.quantity) * 100)
        self.sell_option_at_115price(slice)

    def on_data(self, slice):
        current_time = self.time
        exchange_hours = self.securities[self.equity.Symbol].exchange.hours
        if not exchange_hours.is_open(current_time, False):
            return 
        self.plot("Performance Chart", "Price", self.securities[self.equity.Symbol].price)
        stock_price = self.securities[self.equity.Symbol].price
        holding_options = self.get_holding_option()
        holding_stocks = self.get_holding_stock()
        if len(holding_options) == 0:
            self.sell_on_monday(slice)
            return 
        else:
            self.check_to_buy_back(slice, holding_options, holding_stocks)

    def on_order_event(self, orderEvent):
        if orderEvent.status == OrderStatus.FILLED:
            pass

Sources: Update Order Regression Algorithm, Time In Force Algorithm

I should have my own backtesting node, I don't know why I have to wait for so long

Is there a problem with my backtesting node? Causing me to wait for a long time?

Is there a way for me to restart my backtesting node?