Question

我正在为债券定价建立蒙特卡洛模拟。我这样做是：

我有一个函子（InterestRatePathCreator），当使用种子进行调用时，该函子将生成并返回一个利率向量（向量A）。我的想法是，我需要运行10,000次，并且由于每个计算都与下一个独立，因此我认为异步在这里可以很好地工作。
我将此向量（向量A）返回给我的BondPricer，后者进行一些额外的计算，例如使用我提供的规格对我从债券中获得的现金流量进行折现。这样就产生了一个数字（该迭代期间债券的价格），并将其存储在向量（向量B）中。
然后我平均该向量（向量B）中的项目，这就是我的债券价格。

由于某种原因，由于执行了这些操作，因此我的异步计算要比非异步计算慢，这使我相信自己做错了事。

这两种计算之间的唯一区别是，一种计算使用Async，而另一种则不使用（见下文）。

Functor对象（生成随机利率）

vector<double> InterestRatePathCreator::operator()(int seed) const {

    vector<double> yieldCurve;
    vector<double> discountRates;

    mt19937 randEng(seed);
    normal_distribution<> normDist;

    auto newInterestRate = [this](double previousRate, double norm) {

        double currentRate = previousRate;
        double expArg1 = (riskFreeRate_ - 
                         ((volatility_ * volatility_) / 2));
        double expArg2 = volatility_ * norm * sqrt(timeSteps_);
        currentRate *= exp(expArg1 + expArg2);

        return currentRate; 

    };

    yieldCurve.push_back(discountFactor_);
    double interestRate = discountFactor_;

    for (int k{1}; k <= timeSteps_; k++) {
        interestRate = newInterestRate(interestRate, normDist(randEng));       
        yieldCurve.push_back(interestRate);
    }

    for (int j{}; j < timeSteps_; j++) {
        discountRates.push_back(1.00 / pow(1 + yieldCurve[j], j));
    }

    return discountRates;
}

异步价格计算

void MCBondPricer::computePriceAsync() {

    InterestRatePathCreator irp(paymentFrequency_, 
    discountFactor_, riskFreeRate_, yearsRemaining_, volatility_); 

    vector<std::future<vector<double>>> bondData; // FUTURE
    vector<double> discountedCashFlows;
    vector<double> cashFlows;

    bondData.reserve(trials_);
    discountedCashFlows.reserve(trials_);
    cashFlows.reserve(timeSteps_);

    ////////////////////////////////////////////
    // Several bond-related calculations removed.
    ////////////////////////////////////////////

    generateSeeds();

    for (auto& seed : seedStorage_) {
        bondData.push_back(std::async(irp, seed)); // ASYNC
    }

    for (int i{}; i < trials_; i++) {

        vector<double> discountRates = bondData[i].get(); // GET
        int bondPrice{};

        for (int j{}; j < cashFlows.size(); j++) {

            bondPrice += discountRates[j] * cashFlows[j];

            if (j == cashFlows.size() - 1) {
                discountedCashFlows.push_back(bondPrice);
            }
        }
    }

    price_ = quantity_ * (1.0 / trials_) * 
    std::accumulate(discountedCashFlows.begin(),
                    discountedCashFlows.end(), 0.0);
}

当我对异步进行10,000次试用时，我得到2.5秒，而当我进行非异步时，我得到1.5秒。我不明白什么？

为什么我的ComputeAsync比我的ComputeNonAsync需要更多的时间？

0 个答案: