1085 lines
37 KiB
C++
1085 lines
37 KiB
C++
/*
|
|
* Legal Notice
|
|
*
|
|
* This document and associated source code (the "Work") is a part of a
|
|
* benchmark specification maintained by the TPC.
|
|
*
|
|
* The TPC reserves all right, title, and interest to the Work as provided
|
|
* under U.S. and international laws, including without limitation all patent
|
|
* and trademark rights therein.
|
|
*
|
|
* No Warranty
|
|
*
|
|
* 1.1 TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THE INFORMATION
|
|
* CONTAINED HEREIN IS PROVIDED "AS IS" AND WITH ALL FAULTS, AND THE
|
|
* AUTHORS AND DEVELOPERS OF THE WORK HEREBY DISCLAIM ALL OTHER
|
|
* WARRANTIES AND CONDITIONS, EITHER EXPRESS, IMPLIED OR STATUTORY,
|
|
* INCLUDING, BUT NOT LIMITED TO, ANY (IF ANY) IMPLIED WARRANTIES,
|
|
* DUTIES OR CONDITIONS OF MERCHANTABILITY, OF FITNESS FOR A PARTICULAR
|
|
* PURPOSE, OF ACCURACY OR COMPLETENESS OF RESPONSES, OF RESULTS, OF
|
|
* WORKMANLIKE EFFORT, OF LACK OF VIRUSES, AND OF LACK OF NEGLIGENCE.
|
|
* ALSO, THERE IS NO WARRANTY OR CONDITION OF TITLE, QUIET ENJOYMENT,
|
|
* QUIET POSSESSION, CORRESPONDENCE TO DESCRIPTION OR NON-INFRINGEMENT
|
|
* WITH REGARD TO THE WORK.
|
|
* 1.2 IN NO EVENT WILL ANY AUTHOR OR DEVELOPER OF THE WORK BE LIABLE TO
|
|
* ANY OTHER PARTY FOR ANY DAMAGES, INCLUDING BUT NOT LIMITED TO THE
|
|
* COST OF PROCURING SUBSTITUTE GOODS OR SERVICES, LOST PROFITS, LOSS
|
|
* OF USE, LOSS OF DATA, OR ANY INCIDENTAL, CONSEQUENTIAL, DIRECT,
|
|
* INDIRECT, OR SPECIAL DAMAGES WHETHER UNDER CONTRACT, TORT, WARRANTY,
|
|
* OR OTHERWISE, ARISING IN ANY WAY OUT OF THIS OR ANY OTHER AGREEMENT
|
|
* RELATING TO THE WORK, WHETHER OR NOT SUCH AUTHOR OR DEVELOPER HAD
|
|
* ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.
|
|
*
|
|
* Contributors
|
|
* - Sergey Vasilevskiy, Doug Johnson, Matt Emmerton, Christopher Chan-Nui
|
|
*/
|
|
|
|
/******************************************************************************
|
|
* Description: This file is used to "expose" the configurable driver
|
|
* parameters. These values may be set by test sponsors
|
|
* for testing and prototyping. The default values
|
|
* represent those that must be used for a compliant run.
|
|
******************************************************************************/
|
|
|
|
#ifndef DRIVER_PARAM_SETTINGS_H
|
|
#define DRIVER_PARAM_SETTINGS_H
|
|
|
|
#include <iostream>
|
|
#include <iomanip> // for log message formatting
|
|
#include <sstream> // for log message construction
|
|
|
|
#include "utilities/EGenUtilities_stdafx.h"
|
|
|
|
namespace TPCE {
|
|
|
|
// CHECK tests for CheckValid and CheckCompliant, use macros so we can get a
|
|
// textual representation of the tested values, these tests could be
|
|
// significantly condensed but we're trying for readibility here...
|
|
#define DRIVERPARAM_CHECK_EQUAL(name, lhs, rhs) \
|
|
if ((lhs) != (rhs)) { \
|
|
std::ostringstream strm; \
|
|
strm << #lhs << "(" << (lhs) << ") != " << #rhs << "(" << (rhs) << ")"; \
|
|
throw CCheckErr(name, strm.str()); \
|
|
}
|
|
|
|
#define DRIVERPARAM_CHECK_GE(name, lhs, rhs) \
|
|
if ((lhs) < (rhs)) { \
|
|
std::ostringstream strm; \
|
|
strm << #lhs << "(" << (lhs) << ") < " << #rhs << "(" << (rhs) << ")"; \
|
|
throw CCheckErr(name, strm.str()); \
|
|
}
|
|
|
|
#define DRIVERPARAM_CHECK_LE(name, lhs, rhs) \
|
|
if ((lhs) > (rhs)) { \
|
|
std::ostringstream strm; \
|
|
strm << #lhs << "(" << (lhs) << ") > " << #rhs << "(" << (rhs) << ")"; \
|
|
throw CCheckErr(name, strm.str()); \
|
|
}
|
|
|
|
#define DRIVERPARAM_CHECK_BETWEEN(name, lhs, minval, maxval) \
|
|
DRIVERPARAM_CHECK_GE(name, lhs, minval) \
|
|
DRIVERPARAM_CHECK_LE(name, lhs, maxval)
|
|
|
|
#define DRIVERPARAM_CHECK_DEFAULT(name) \
|
|
if (cur.name != dft.name) { \
|
|
std::ostringstream strm; \
|
|
strm << #name << "(" << cur.name << ") != " << dft.name; \
|
|
throw CCheckErr(#name, strm.str()); \
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Parameter Base Class Template
|
|
******************************************************************************/
|
|
template <typename T> class CParametersWithoutDefaults {
|
|
public:
|
|
T cur;
|
|
|
|
CParametersWithoutDefaults() {
|
|
}
|
|
/*
|
|
* Virtual destructor. Provided so that a sponsor-specific
|
|
* destructor can be called on destruction from the base-class pointer.
|
|
*
|
|
* PARAMETERS:
|
|
* none.
|
|
*
|
|
* RETURNS:
|
|
* not applicable.
|
|
*/
|
|
virtual ~CParametersWithoutDefaults(){};
|
|
|
|
virtual void CheckValid(void) = 0;
|
|
virtual void CheckCompliant(void) = 0;
|
|
bool IsValid(void) {
|
|
try {
|
|
CheckValid();
|
|
return true;
|
|
} catch (CCheckErr) {
|
|
throw;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool IsCompliant(void) {
|
|
// This will always return true for the classes defined in this file
|
|
try {
|
|
CheckCompliant();
|
|
return true;
|
|
} catch (CCheckErr) {
|
|
throw;
|
|
return false;
|
|
}
|
|
}
|
|
};
|
|
|
|
template <typename T, typename T2> class CParametersWithDefaults {
|
|
// protected:
|
|
public:
|
|
T dft;
|
|
T2 state;
|
|
|
|
public:
|
|
T cur;
|
|
|
|
CParametersWithDefaults() {
|
|
}
|
|
/*
|
|
* Virtual destructor. Provided so that a sponsor-specific
|
|
* destructor can be called on destruction from the base-class pointer.
|
|
*
|
|
* PARAMETERS:
|
|
* none.
|
|
*
|
|
* RETURNS:
|
|
* not applicable.
|
|
*/
|
|
virtual ~CParametersWithDefaults(){};
|
|
|
|
void Initialize(void) {
|
|
InitializeDefaults();
|
|
SetToDefaults();
|
|
}
|
|
|
|
void SetToDefaults(void) {
|
|
cur = dft;
|
|
CheckDefaults();
|
|
}
|
|
|
|
virtual void InitializeDefaults(void) {
|
|
}
|
|
virtual void CheckDefaults(void) {
|
|
}
|
|
virtual void CheckValid(void) = 0;
|
|
virtual void CheckCompliant(void) = 0;
|
|
bool IsValid(void) {
|
|
try {
|
|
CheckValid();
|
|
return true;
|
|
} catch (CCheckErr) {
|
|
throw;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool IsCompliant(void) {
|
|
try {
|
|
CheckCompliant();
|
|
return true;
|
|
} catch (CCheckErr) {
|
|
throw;
|
|
return false;
|
|
}
|
|
}
|
|
};
|
|
|
|
/******************************************************************************
|
|
* Parameter Structures (Data)
|
|
******************************************************************************/
|
|
typedef struct TBrokerVolumeSettings {
|
|
} * PBrokerVolumeSettings;
|
|
|
|
typedef struct TCustomerPositionSettings {
|
|
INT32 by_cust_id; // percentage
|
|
INT32 by_tax_id; // percentage
|
|
INT32 get_history; // percentage
|
|
} * PCustomerPositionSettings;
|
|
|
|
typedef struct TMarketWatchSettings {
|
|
INT32 by_acct_id; // percentage
|
|
INT32 by_industry; // percentage
|
|
INT32 by_watch_list; // percentage
|
|
} * PMarketWatchSettings;
|
|
|
|
typedef struct TSecurityDetailSettings {
|
|
INT32 LOBAccessPercentage;
|
|
} * PSecurityDetailSettings;
|
|
|
|
typedef struct TTradeLookupSettings {
|
|
INT32 do_frame1; // percentage
|
|
INT32 do_frame2; // percentage
|
|
INT32 do_frame3; // percentage
|
|
INT32 do_frame4; // percentage
|
|
|
|
INT32 MaxRowsFrame1; // Max number of trades for frame
|
|
|
|
INT32 BackOffFromEndTimeFrame2; // Used to cap time interval generated.
|
|
INT32 MaxRowsFrame2; // Max number of trades for frame
|
|
|
|
INT32 BackOffFromEndTimeFrame3; // Used to cap time interval generated.
|
|
INT32 MaxRowsFrame3; // Max number of trades for frame
|
|
|
|
INT32 BackOffFromEndTimeFrame4; // Used to cap time interval generated.
|
|
INT32 MaxRowsFrame4; // Max number of rows for frame
|
|
} * PTradeLookupSettings;
|
|
|
|
typedef struct TTradeOrderSettings {
|
|
INT32 market;
|
|
INT32 limit;
|
|
INT32 stop_loss;
|
|
INT32 security_by_name;
|
|
INT32 security_by_symbol;
|
|
INT32 buy_orders;
|
|
INT32 sell_orders;
|
|
INT32 lifo;
|
|
INT32 exec_is_owner;
|
|
INT32 rollback;
|
|
INT32 type_is_margin;
|
|
} * PTradeOrderSettings;
|
|
|
|
typedef struct TTradeUpdateSettings {
|
|
INT32 do_frame1; // percentage
|
|
INT32 do_frame2; // percentage
|
|
INT32 do_frame3; // percentage
|
|
|
|
INT32 MaxRowsFrame1; // Max number of trades for frame
|
|
INT32 MaxRowsToUpdateFrame1; // Max number of rows to update
|
|
|
|
INT32 BackOffFromEndTimeFrame2; // Used to cap time interval generated.
|
|
INT32 MaxRowsFrame2; // Max number of trades for frame
|
|
INT32 MaxRowsToUpdateFrame2; // Max number of rows to update
|
|
|
|
INT32 BackOffFromEndTimeFrame3; // Used to cap time interval generated.
|
|
INT32 MaxRowsFrame3; // Max number of trades for frame
|
|
INT32 MaxRowsToUpdateFrame3; // Max number of rows to update
|
|
} * PTradeUpdateSettings;
|
|
|
|
typedef struct TTxnMixGeneratorSettings {
|
|
// Market-Feed and Trade-Result settings don't really alter the mix.
|
|
// They are done as a by-product of Trade-Orders. However, the values
|
|
// still need to be set correctly because they get used when generating
|
|
// the random number for selecting the other transaction types.
|
|
INT32 BrokerVolumeMixLevel;
|
|
INT32 CustomerPositionMixLevel;
|
|
INT32 MarketFeedMixLevel;
|
|
INT32 MarketWatchMixLevel;
|
|
INT32 SecurityDetailMixLevel;
|
|
INT32 TradeLookupMixLevel;
|
|
INT32 TradeOrderMixLevel;
|
|
INT32 TradeResultMixLevel;
|
|
INT32 TradeStatusMixLevel;
|
|
INT32 TradeUpdateMixLevel;
|
|
|
|
// Transaction mix levels are expressed out of a total of 1000.
|
|
INT32 TransactionMixTotal;
|
|
} * PTxnMixGeneratorSettings;
|
|
|
|
typedef struct TLoaderSettings {
|
|
TIdent iConfiguredCustomerCount;
|
|
TIdent iActiveCustomerCount;
|
|
INT32 iScaleFactor;
|
|
INT32 iDaysOfInitialTrades;
|
|
TIdent iStartingCustomer;
|
|
TIdent iCustomerCount;
|
|
} * pLoaderSettings;
|
|
|
|
typedef struct TDriverGlobalSettings {
|
|
TIdent iConfiguredCustomerCount;
|
|
TIdent iActiveCustomerCount;
|
|
INT32 iScaleFactor;
|
|
INT32 iDaysOfInitialTrades;
|
|
} * PDriverGlobalSettings;
|
|
|
|
typedef struct TDriverCESettings {
|
|
UINT32 UniqueId;
|
|
RNGSEED TxnMixRNGSeed;
|
|
RNGSEED TxnInputRNGSeed;
|
|
} * PDriverCESettings;
|
|
|
|
typedef struct TDriverCEPartitionSettings {
|
|
TIdent iMyStartingCustomerId;
|
|
TIdent iMyCustomerCount;
|
|
INT32 iPartitionPercent;
|
|
} * PDriverCEPartitionSettings;
|
|
|
|
typedef struct TDriverMEESettings {
|
|
UINT32 UniqueId;
|
|
RNGSEED RNGSeed;
|
|
RNGSEED TickerTapeRNGSeed;
|
|
RNGSEED TradingFloorRNGSeed;
|
|
} * PDriverMEESettings;
|
|
|
|
typedef struct TDriverDMSettings {
|
|
UINT32 UniqueId;
|
|
RNGSEED RNGSeed;
|
|
} * PDriverDMSettings;
|
|
|
|
/******************************************************************************
|
|
* Parameter Structures (Boolean "Is Default" State)
|
|
******************************************************************************/
|
|
struct TBrokerVolumeSettingsState {};
|
|
|
|
struct TCustomerPositionSettingsState {
|
|
bool by_cust_id; // percentage
|
|
bool by_tax_id; // percentage
|
|
bool get_history; // percentage
|
|
};
|
|
|
|
struct TMarketWatchSettingsState {
|
|
bool by_acct_id; // percentage
|
|
bool by_industry; // percentage
|
|
bool by_watch_list; // percentage
|
|
};
|
|
|
|
struct TSecurityDetailSettingsState {
|
|
bool LOBAccessPercentage;
|
|
};
|
|
|
|
struct TTradeLookupSettingsState {
|
|
bool do_frame1; // percentage
|
|
bool do_frame2; // percentage
|
|
bool do_frame3; // percentage
|
|
bool do_frame4; // percentage
|
|
|
|
bool MaxRowsFrame1; // Max number of trades for frame
|
|
|
|
bool BackOffFromEndTimeFrame2; // Used to cap time interval generated.
|
|
bool MaxRowsFrame2; // Max number of trades for frame
|
|
|
|
bool BackOffFromEndTimeFrame3; // Used to cap time interval generated.
|
|
bool MaxRowsFrame3; // Max number of trades for frame
|
|
|
|
bool BackOffFromEndTimeFrame4; // Used to cap time interval generated.
|
|
bool MaxRowsFrame4; // Max number of rows for frame
|
|
};
|
|
|
|
struct TTradeOrderSettingsState {
|
|
bool market;
|
|
bool limit;
|
|
bool stop_loss;
|
|
bool security_by_name;
|
|
bool security_by_symbol;
|
|
bool buy_orders;
|
|
bool sell_orders;
|
|
bool lifo;
|
|
bool exec_is_owner;
|
|
bool rollback;
|
|
bool type_is_margin;
|
|
};
|
|
|
|
struct TTradeUpdateSettingsState {
|
|
bool do_frame1; // percentage
|
|
bool do_frame2; // percentage
|
|
bool do_frame3; // percentage
|
|
|
|
bool MaxRowsFrame1; // Max number of trades for frame
|
|
bool MaxRowsToUpdateFrame1; // Max number of rows to update
|
|
|
|
bool BackOffFromEndTimeFrame2; // Used to cap time interval generated.
|
|
bool MaxRowsFrame2; // Max number of trades for frame
|
|
bool MaxRowsToUpdateFrame2; // Max number of rows to update
|
|
|
|
bool BackOffFromEndTimeFrame3; // Used to cap time interval generated.
|
|
bool MaxRowsFrame3; // Max number of trades for frame
|
|
bool MaxRowsToUpdateFrame3; // Max number of rows to update
|
|
};
|
|
|
|
struct TTxnMixGeneratorSettingsState {
|
|
bool BrokerVolumeMixLevel;
|
|
bool CustomerPositionMixLevel;
|
|
bool MarketWatchMixLevel;
|
|
bool SecurityDetailMixLevel;
|
|
bool TradeLookupMixLevel;
|
|
bool TradeOrderMixLevel;
|
|
bool TradeStatusMixLevel;
|
|
bool TradeUpdateMixLevel;
|
|
bool TransactionMixTotal;
|
|
};
|
|
|
|
struct TLoaderSettingsState {
|
|
bool iConfiguredCustomerCount;
|
|
bool iActiveCustomerCount;
|
|
bool iScaleFactor;
|
|
bool iDaysOfInitialTrades;
|
|
bool iStartingCustomer;
|
|
bool iCustomerCount;
|
|
};
|
|
|
|
struct TDriverCEPartitionSettingsState {
|
|
bool iPartitionPercent;
|
|
};
|
|
|
|
struct TDriverGlobalSettingsState {
|
|
bool iConfiguredCustomerCount;
|
|
bool iActiveCustomerCount;
|
|
bool iScaleFactor;
|
|
bool iDaysOfInitialTrades;
|
|
};
|
|
|
|
/******************************************************************************
|
|
* Parameter Derived Class / Template Instantiation
|
|
******************************************************************************/
|
|
class CBrokerVolumeSettings
|
|
: public CParametersWithDefaults<struct TBrokerVolumeSettings, struct TBrokerVolumeSettingsState> {
|
|
public:
|
|
CBrokerVolumeSettings() {
|
|
Initialize();
|
|
}
|
|
|
|
void InitializeDefaults(void) {
|
|
}
|
|
|
|
void CheckDefaults(void) {
|
|
}
|
|
|
|
void CheckValid(void) {
|
|
}
|
|
|
|
void CheckCompliant(void) {
|
|
}
|
|
};
|
|
|
|
class CCustomerPositionSettings
|
|
: public CParametersWithDefaults<struct TCustomerPositionSettings, struct TCustomerPositionSettingsState> {
|
|
public:
|
|
CCustomerPositionSettings() {
|
|
Initialize();
|
|
}
|
|
|
|
void InitializeDefaults(void) {
|
|
dft.by_cust_id = 50;
|
|
dft.by_tax_id = 50;
|
|
dft.get_history = 50;
|
|
}
|
|
|
|
void CheckDefaults(void) {
|
|
state.by_cust_id = (cur.by_cust_id == dft.by_cust_id);
|
|
state.by_tax_id = (cur.by_tax_id == dft.by_tax_id);
|
|
state.get_history = (cur.get_history == dft.get_history);
|
|
}
|
|
|
|
void CheckValid(void) {
|
|
DRIVERPARAM_CHECK_BETWEEN("by_cust_id", cur.by_cust_id, 0, 100);
|
|
DRIVERPARAM_CHECK_BETWEEN("by_tax_id", cur.by_tax_id, 0, 100);
|
|
DRIVERPARAM_CHECK_EQUAL("by_*_id total", cur.by_cust_id + cur.by_tax_id, 100);
|
|
DRIVERPARAM_CHECK_BETWEEN("get_history", cur.get_history, 0, 100);
|
|
}
|
|
|
|
void CheckCompliant(void) {
|
|
CheckValid();
|
|
DRIVERPARAM_CHECK_DEFAULT(by_cust_id);
|
|
DRIVERPARAM_CHECK_DEFAULT(by_tax_id);
|
|
DRIVERPARAM_CHECK_DEFAULT(get_history);
|
|
}
|
|
};
|
|
|
|
class CMarketWatchSettings
|
|
: public CParametersWithDefaults<struct TMarketWatchSettings, struct TMarketWatchSettingsState> {
|
|
public:
|
|
CMarketWatchSettings() {
|
|
Initialize();
|
|
}
|
|
|
|
void InitializeDefaults(void) {
|
|
dft.by_acct_id = 35;
|
|
dft.by_industry = 5;
|
|
dft.by_watch_list = 60;
|
|
}
|
|
|
|
void CheckDefaults(void) {
|
|
state.by_acct_id = (cur.by_acct_id == dft.by_acct_id);
|
|
state.by_industry = (cur.by_industry == dft.by_industry);
|
|
state.by_watch_list = (cur.by_watch_list == dft.by_watch_list);
|
|
}
|
|
|
|
void CheckValid(void) {
|
|
DRIVERPARAM_CHECK_BETWEEN("by_acct_id", cur.by_acct_id, 0, 100);
|
|
DRIVERPARAM_CHECK_BETWEEN("by_industry", cur.by_industry, 0, 100);
|
|
DRIVERPARAM_CHECK_BETWEEN("by_watch_list", cur.by_watch_list, 0, 100);
|
|
DRIVERPARAM_CHECK_EQUAL("by_* total", cur.by_acct_id + cur.by_industry + cur.by_watch_list, 100);
|
|
}
|
|
|
|
void CheckCompliant(void) {
|
|
CheckValid();
|
|
DRIVERPARAM_CHECK_DEFAULT(by_acct_id);
|
|
DRIVERPARAM_CHECK_DEFAULT(by_industry);
|
|
DRIVERPARAM_CHECK_DEFAULT(by_watch_list);
|
|
}
|
|
};
|
|
|
|
class CSecurityDetailSettings
|
|
: public CParametersWithDefaults<struct TSecurityDetailSettings, struct TSecurityDetailSettingsState> {
|
|
public:
|
|
CSecurityDetailSettings() {
|
|
Initialize();
|
|
}
|
|
|
|
void InitializeDefaults(void) {
|
|
dft.LOBAccessPercentage = 1;
|
|
}
|
|
|
|
void CheckDefaults(void) {
|
|
state.LOBAccessPercentage = (cur.LOBAccessPercentage == dft.LOBAccessPercentage);
|
|
}
|
|
|
|
void CheckValid(void) {
|
|
DRIVERPARAM_CHECK_BETWEEN("LOBAccessPercentage", cur.LOBAccessPercentage, 0, 100);
|
|
}
|
|
|
|
void CheckCompliant(void) {
|
|
CheckValid();
|
|
DRIVERPARAM_CHECK_DEFAULT(LOBAccessPercentage);
|
|
}
|
|
};
|
|
|
|
class CTradeLookupSettings
|
|
: public CParametersWithDefaults<struct TTradeLookupSettings, struct TTradeLookupSettingsState> {
|
|
public:
|
|
CTradeLookupSettings() {
|
|
Initialize();
|
|
}
|
|
|
|
void InitializeDefaults(void) {
|
|
dft.do_frame1 = 30;
|
|
dft.do_frame2 = 30;
|
|
dft.do_frame3 = 30;
|
|
dft.do_frame4 = 10;
|
|
dft.MaxRowsFrame1 = 20;
|
|
dft.BackOffFromEndTimeFrame2 = 4 * 8 * 3600; // four 8-hour days or 32 hours
|
|
dft.MaxRowsFrame2 = 20;
|
|
dft.BackOffFromEndTimeFrame3 = 200 * 60; // 200 minutes
|
|
dft.MaxRowsFrame3 = 20;
|
|
dft.BackOffFromEndTimeFrame4 = 500 * 60; // 30,000 seconds
|
|
dft.MaxRowsFrame4 = 20;
|
|
}
|
|
|
|
void CheckDefaults(void) {
|
|
state.do_frame1 = (cur.do_frame1 == dft.do_frame1);
|
|
state.do_frame2 = (cur.do_frame2 == dft.do_frame2);
|
|
state.do_frame3 = (cur.do_frame3 == dft.do_frame3);
|
|
state.do_frame4 = (cur.do_frame4 == dft.do_frame4);
|
|
state.MaxRowsFrame1 = (cur.MaxRowsFrame1 == dft.MaxRowsFrame1);
|
|
state.BackOffFromEndTimeFrame2 = (cur.BackOffFromEndTimeFrame2 == dft.BackOffFromEndTimeFrame2);
|
|
state.MaxRowsFrame2 = (cur.MaxRowsFrame2 == dft.MaxRowsFrame2);
|
|
state.BackOffFromEndTimeFrame3 = (cur.BackOffFromEndTimeFrame3 == dft.BackOffFromEndTimeFrame3);
|
|
state.MaxRowsFrame3 = (cur.MaxRowsFrame3 == dft.MaxRowsFrame3);
|
|
state.BackOffFromEndTimeFrame4 = (cur.BackOffFromEndTimeFrame4 == dft.BackOffFromEndTimeFrame4);
|
|
state.MaxRowsFrame4 = (cur.MaxRowsFrame4 == dft.MaxRowsFrame4);
|
|
}
|
|
|
|
void CheckValid(void) {
|
|
DRIVERPARAM_CHECK_BETWEEN("do_frame1", cur.do_frame1, 0, 100);
|
|
DRIVERPARAM_CHECK_BETWEEN("do_frame2", cur.do_frame2, 0, 100);
|
|
DRIVERPARAM_CHECK_BETWEEN("do_frame3", cur.do_frame3, 0, 100);
|
|
DRIVERPARAM_CHECK_BETWEEN("do_frame4", cur.do_frame4, 0, 100);
|
|
DRIVERPARAM_CHECK_EQUAL("do_frame* total", cur.do_frame1 + cur.do_frame2 + cur.do_frame3 + cur.do_frame4, 100);
|
|
DRIVERPARAM_CHECK_LE("MaxRowsFrame1", cur.MaxRowsFrame1, TradeLookupFrame1MaxRows);
|
|
DRIVERPARAM_CHECK_LE("MaxRowsFrame2", cur.MaxRowsFrame2, TradeLookupFrame2MaxRows);
|
|
DRIVERPARAM_CHECK_LE("MaxRowsFrame3", cur.MaxRowsFrame3, TradeLookupFrame3MaxRows);
|
|
DRIVERPARAM_CHECK_LE("MaxRowsFrame4", cur.MaxRowsFrame4, TradeLookupFrame4MaxRows);
|
|
}
|
|
|
|
void CheckCompliant(void) {
|
|
CheckValid();
|
|
DRIVERPARAM_CHECK_DEFAULT(do_frame1);
|
|
DRIVERPARAM_CHECK_DEFAULT(do_frame2);
|
|
DRIVERPARAM_CHECK_DEFAULT(do_frame3);
|
|
DRIVERPARAM_CHECK_DEFAULT(do_frame4);
|
|
DRIVERPARAM_CHECK_DEFAULT(MaxRowsFrame1);
|
|
DRIVERPARAM_CHECK_DEFAULT(BackOffFromEndTimeFrame2);
|
|
DRIVERPARAM_CHECK_DEFAULT(MaxRowsFrame2);
|
|
DRIVERPARAM_CHECK_DEFAULT(BackOffFromEndTimeFrame3);
|
|
DRIVERPARAM_CHECK_DEFAULT(MaxRowsFrame3);
|
|
DRIVERPARAM_CHECK_DEFAULT(BackOffFromEndTimeFrame4);
|
|
DRIVERPARAM_CHECK_DEFAULT(MaxRowsFrame4);
|
|
}
|
|
};
|
|
|
|
class CTradeOrderSettings
|
|
: public CParametersWithDefaults<struct TTradeOrderSettings, struct TTradeOrderSettingsState> {
|
|
public:
|
|
CTradeOrderSettings() {
|
|
Initialize();
|
|
}
|
|
|
|
void InitializeDefaults(void) {
|
|
dft.market = 60;
|
|
dft.limit = 40;
|
|
dft.stop_loss = 50;
|
|
dft.security_by_name = 40;
|
|
dft.security_by_symbol = 60;
|
|
dft.buy_orders = 50;
|
|
dft.sell_orders = 50;
|
|
dft.lifo = 35;
|
|
dft.exec_is_owner = 90;
|
|
dft.rollback = 1;
|
|
dft.type_is_margin = 8;
|
|
}
|
|
|
|
void CheckDefaults(void) {
|
|
state.market = (cur.market == dft.market);
|
|
state.limit = (cur.limit == dft.limit);
|
|
state.stop_loss = (cur.stop_loss == dft.stop_loss);
|
|
state.security_by_name = (cur.security_by_name == dft.security_by_name);
|
|
state.security_by_symbol = (cur.security_by_symbol == dft.security_by_symbol);
|
|
state.buy_orders = (cur.buy_orders == dft.buy_orders);
|
|
state.sell_orders = (cur.sell_orders == dft.sell_orders);
|
|
state.lifo = (cur.lifo == dft.lifo);
|
|
state.exec_is_owner = (cur.exec_is_owner == dft.exec_is_owner);
|
|
state.rollback = (cur.rollback == dft.rollback);
|
|
state.type_is_margin = (cur.type_is_margin == dft.type_is_margin);
|
|
}
|
|
|
|
void CheckValid(void) {
|
|
DRIVERPARAM_CHECK_BETWEEN("market", cur.market, 0, 100);
|
|
DRIVERPARAM_CHECK_BETWEEN("limit", cur.limit, 0, 100);
|
|
DRIVERPARAM_CHECK_EQUAL("market or limit total", cur.market + cur.limit, 100);
|
|
DRIVERPARAM_CHECK_BETWEEN("stop_loss", cur.stop_loss, 0, 100);
|
|
DRIVERPARAM_CHECK_BETWEEN("security_by_name", cur.security_by_name, 0, 100);
|
|
DRIVERPARAM_CHECK_BETWEEN("security_by_symbol", cur.security_by_symbol, 0, 100);
|
|
DRIVERPARAM_CHECK_EQUAL("security_by_* total", cur.security_by_name + cur.security_by_symbol, 100);
|
|
DRIVERPARAM_CHECK_BETWEEN("buy_orders", cur.buy_orders, 0, 100);
|
|
DRIVERPARAM_CHECK_BETWEEN("sell_orders", cur.sell_orders, 0, 100);
|
|
DRIVERPARAM_CHECK_EQUAL("*_orders total", cur.buy_orders + cur.sell_orders, 100);
|
|
DRIVERPARAM_CHECK_BETWEEN("lifo", cur.lifo, 0, 100);
|
|
DRIVERPARAM_CHECK_BETWEEN("exec_is_owner", cur.exec_is_owner, 0, 100);
|
|
DRIVERPARAM_CHECK_BETWEEN("rollback", cur.rollback, 0, 100);
|
|
DRIVERPARAM_CHECK_BETWEEN("type_is_margin", cur.type_is_margin, 0, 100);
|
|
}
|
|
|
|
void CheckCompliant(void) {
|
|
CheckValid();
|
|
DRIVERPARAM_CHECK_BETWEEN("exec_is_owner", cur.exec_is_owner, 60, 100);
|
|
DRIVERPARAM_CHECK_DEFAULT(market);
|
|
DRIVERPARAM_CHECK_DEFAULT(limit);
|
|
DRIVERPARAM_CHECK_DEFAULT(stop_loss);
|
|
DRIVERPARAM_CHECK_DEFAULT(security_by_name);
|
|
DRIVERPARAM_CHECK_DEFAULT(security_by_symbol);
|
|
DRIVERPARAM_CHECK_DEFAULT(buy_orders);
|
|
DRIVERPARAM_CHECK_DEFAULT(sell_orders);
|
|
DRIVERPARAM_CHECK_DEFAULT(lifo);
|
|
DRIVERPARAM_CHECK_DEFAULT(exec_is_owner);
|
|
DRIVERPARAM_CHECK_DEFAULT(rollback);
|
|
DRIVERPARAM_CHECK_DEFAULT(type_is_margin);
|
|
}
|
|
};
|
|
|
|
class CTradeUpdateSettings
|
|
: public CParametersWithDefaults<struct TTradeUpdateSettings, struct TTradeUpdateSettingsState> {
|
|
public:
|
|
CTradeUpdateSettings() {
|
|
Initialize();
|
|
}
|
|
|
|
void InitializeDefaults(void) {
|
|
dft.do_frame1 = 33;
|
|
dft.do_frame2 = 33;
|
|
dft.do_frame3 = 34;
|
|
dft.MaxRowsFrame1 = 20;
|
|
dft.MaxRowsToUpdateFrame1 = 20;
|
|
dft.MaxRowsFrame2 = 20;
|
|
dft.MaxRowsToUpdateFrame2 = 20;
|
|
dft.BackOffFromEndTimeFrame2 = 4 * 8 * 3600; // four 8-hour days or 32 hours
|
|
dft.MaxRowsFrame3 = 20;
|
|
dft.MaxRowsToUpdateFrame3 = 20;
|
|
dft.BackOffFromEndTimeFrame3 = 200 * 60; // 200 minutes
|
|
}
|
|
|
|
void CheckDefaults(void) {
|
|
state.do_frame1 = (cur.do_frame1 == dft.do_frame1);
|
|
state.do_frame2 = (cur.do_frame2 == dft.do_frame2);
|
|
state.do_frame3 = (cur.do_frame3 == dft.do_frame3);
|
|
state.MaxRowsFrame1 = (cur.MaxRowsFrame1 == dft.MaxRowsFrame1);
|
|
state.MaxRowsToUpdateFrame1 = (cur.MaxRowsToUpdateFrame1 == dft.MaxRowsToUpdateFrame1);
|
|
state.MaxRowsFrame2 = (cur.MaxRowsFrame2 == dft.MaxRowsFrame2);
|
|
state.MaxRowsToUpdateFrame2 = (cur.MaxRowsToUpdateFrame2 == dft.MaxRowsToUpdateFrame2);
|
|
state.BackOffFromEndTimeFrame2 = (cur.BackOffFromEndTimeFrame2 == dft.BackOffFromEndTimeFrame2);
|
|
state.MaxRowsFrame3 = (cur.MaxRowsFrame3 == dft.MaxRowsFrame3);
|
|
state.MaxRowsToUpdateFrame3 = (cur.MaxRowsToUpdateFrame3 == dft.MaxRowsToUpdateFrame3);
|
|
state.BackOffFromEndTimeFrame3 = (cur.BackOffFromEndTimeFrame3 == dft.BackOffFromEndTimeFrame3);
|
|
}
|
|
|
|
void CheckValid(void) {
|
|
DRIVERPARAM_CHECK_BETWEEN("do_frame1", cur.do_frame1, 0, 100);
|
|
DRIVERPARAM_CHECK_BETWEEN("do_frame2", cur.do_frame2, 0, 100);
|
|
DRIVERPARAM_CHECK_BETWEEN("do_frame3", cur.do_frame3, 0, 100);
|
|
DRIVERPARAM_CHECK_EQUAL("do_frame* total", cur.do_frame1 + cur.do_frame2 + cur.do_frame3, 100);
|
|
DRIVERPARAM_CHECK_LE("MaxRowsFrame1", cur.MaxRowsFrame1, TradeUpdateFrame1MaxRows);
|
|
DRIVERPARAM_CHECK_LE("MaxRowsFrame2", cur.MaxRowsFrame2, TradeUpdateFrame2MaxRows);
|
|
DRIVERPARAM_CHECK_LE("MaxRowsFrame3", cur.MaxRowsFrame3, TradeUpdateFrame3MaxRows);
|
|
DRIVERPARAM_CHECK_LE("MaxRowsToUpdateFrame1", cur.MaxRowsToUpdateFrame1, TradeUpdateFrame1MaxRows);
|
|
DRIVERPARAM_CHECK_LE("MaxRowsToUpdateFrame2", cur.MaxRowsToUpdateFrame2, TradeUpdateFrame2MaxRows);
|
|
DRIVERPARAM_CHECK_LE("MaxRowsToUpdateFrame3", cur.MaxRowsToUpdateFrame3, TradeUpdateFrame3MaxRows);
|
|
}
|
|
|
|
void CheckCompliant(void) {
|
|
CheckValid();
|
|
|
|
DRIVERPARAM_CHECK_DEFAULT(do_frame1);
|
|
DRIVERPARAM_CHECK_DEFAULT(do_frame2);
|
|
DRIVERPARAM_CHECK_DEFAULT(do_frame3);
|
|
DRIVERPARAM_CHECK_DEFAULT(MaxRowsFrame1);
|
|
DRIVERPARAM_CHECK_DEFAULT(MaxRowsToUpdateFrame1);
|
|
DRIVERPARAM_CHECK_DEFAULT(MaxRowsFrame2);
|
|
DRIVERPARAM_CHECK_DEFAULT(MaxRowsToUpdateFrame2);
|
|
DRIVERPARAM_CHECK_DEFAULT(BackOffFromEndTimeFrame2);
|
|
DRIVERPARAM_CHECK_DEFAULT(MaxRowsFrame3);
|
|
DRIVERPARAM_CHECK_DEFAULT(MaxRowsToUpdateFrame3);
|
|
DRIVERPARAM_CHECK_DEFAULT(BackOffFromEndTimeFrame3);
|
|
}
|
|
};
|
|
|
|
class CTxnMixGeneratorSettings
|
|
: public CParametersWithDefaults<struct TTxnMixGeneratorSettings, struct TTxnMixGeneratorSettingsState> {
|
|
public:
|
|
CTxnMixGeneratorSettings() {
|
|
Initialize();
|
|
}
|
|
|
|
void InitializeDefaults(void) {
|
|
dft.BrokerVolumeMixLevel = 49;
|
|
dft.CustomerPositionMixLevel = 130;
|
|
dft.MarketWatchMixLevel = 180;
|
|
dft.SecurityDetailMixLevel = 140;
|
|
dft.TradeLookupMixLevel = 80;
|
|
dft.TradeOrderMixLevel = 101;
|
|
dft.TradeStatusMixLevel = 190;
|
|
dft.TradeUpdateMixLevel = 20;
|
|
}
|
|
|
|
void CheckDefaults(void) {
|
|
state.BrokerVolumeMixLevel = (cur.BrokerVolumeMixLevel == dft.BrokerVolumeMixLevel);
|
|
state.CustomerPositionMixLevel = (cur.CustomerPositionMixLevel == dft.CustomerPositionMixLevel);
|
|
state.MarketWatchMixLevel = (cur.MarketWatchMixLevel == dft.MarketWatchMixLevel);
|
|
state.SecurityDetailMixLevel = (cur.SecurityDetailMixLevel == dft.SecurityDetailMixLevel);
|
|
state.TradeLookupMixLevel = (cur.TradeLookupMixLevel == dft.TradeLookupMixLevel);
|
|
state.TradeOrderMixLevel = (cur.TradeOrderMixLevel == dft.TradeOrderMixLevel);
|
|
state.TradeStatusMixLevel = (cur.TradeStatusMixLevel == dft.TradeStatusMixLevel);
|
|
state.TradeUpdateMixLevel = (cur.TradeUpdateMixLevel == dft.TradeUpdateMixLevel);
|
|
}
|
|
|
|
void CheckValid(void) {
|
|
DRIVERPARAM_CHECK_GE("BrokerVolumeMixLevel", cur.BrokerVolumeMixLevel, 0);
|
|
DRIVERPARAM_CHECK_GE("CustomerPositionMixLevel", cur.CustomerPositionMixLevel, 0);
|
|
DRIVERPARAM_CHECK_GE("MarketWatchMixLevel", cur.MarketWatchMixLevel, 0);
|
|
DRIVERPARAM_CHECK_GE("SecurityDetailMixLevel", cur.SecurityDetailMixLevel, 0);
|
|
DRIVERPARAM_CHECK_GE("TradeLookupMixLevel", cur.TradeLookupMixLevel, 0);
|
|
DRIVERPARAM_CHECK_GE("TradeOrderMixLevel", cur.TradeOrderMixLevel, 0);
|
|
DRIVERPARAM_CHECK_GE("TradeStatusMixLevel", cur.TradeStatusMixLevel, 0);
|
|
DRIVERPARAM_CHECK_GE("TradeUpdateMixLevel", cur.TradeUpdateMixLevel, 0);
|
|
}
|
|
|
|
void CheckCompliant(void) {
|
|
CheckValid();
|
|
DRIVERPARAM_CHECK_DEFAULT(BrokerVolumeMixLevel);
|
|
DRIVERPARAM_CHECK_DEFAULT(CustomerPositionMixLevel);
|
|
DRIVERPARAM_CHECK_DEFAULT(MarketWatchMixLevel);
|
|
DRIVERPARAM_CHECK_DEFAULT(SecurityDetailMixLevel);
|
|
DRIVERPARAM_CHECK_DEFAULT(TradeLookupMixLevel);
|
|
DRIVERPARAM_CHECK_DEFAULT(TradeOrderMixLevel);
|
|
DRIVERPARAM_CHECK_DEFAULT(TradeStatusMixLevel);
|
|
DRIVERPARAM_CHECK_DEFAULT(TradeUpdateMixLevel);
|
|
}
|
|
};
|
|
|
|
class CLoaderSettings : public CParametersWithDefaults<struct TLoaderSettings, struct TLoaderSettingsState> {
|
|
public:
|
|
CLoaderSettings(TIdent iConfiguredCustomerCount, TIdent iActiveCustomerCount, TIdent iStartingCustomer,
|
|
TIdent iCustomerCount, INT32 iScaleFactor, INT32 iDaysOfInitialTrades) {
|
|
Initialize();
|
|
|
|
cur.iConfiguredCustomerCount = iConfiguredCustomerCount;
|
|
cur.iActiveCustomerCount = iActiveCustomerCount;
|
|
cur.iStartingCustomer = iStartingCustomer;
|
|
cur.iCustomerCount = iCustomerCount;
|
|
cur.iScaleFactor = iScaleFactor;
|
|
cur.iDaysOfInitialTrades = iDaysOfInitialTrades;
|
|
|
|
CheckDefaults();
|
|
}
|
|
|
|
CLoaderSettings() {
|
|
Initialize();
|
|
}
|
|
|
|
void InitializeDefaults(void) {
|
|
// NOTE: All of these parameters should match the default values hard-
|
|
// coded in src/EGenLoader.cpp via the variable names listed below.
|
|
dft.iConfiguredCustomerCount = 5000; // iDefaultCustomerCount
|
|
dft.iActiveCustomerCount = 5000; // iDefaultCustomerCount
|
|
dft.iStartingCustomer = 1; // iDefaultStartFromCustomer
|
|
dft.iCustomerCount = 5000; // iDefaultCustomerCount
|
|
dft.iScaleFactor = 500; // iScaleFactor
|
|
dft.iDaysOfInitialTrades = 300; // iDaysOfInitialTrades
|
|
}
|
|
|
|
void CheckDefaults(void) {
|
|
state.iConfiguredCustomerCount = true;
|
|
state.iActiveCustomerCount = true;
|
|
state.iStartingCustomer = true;
|
|
state.iCustomerCount = true;
|
|
state.iScaleFactor = (cur.iScaleFactor == dft.iScaleFactor);
|
|
state.iDaysOfInitialTrades = (cur.iDaysOfInitialTrades == dft.iDaysOfInitialTrades);
|
|
}
|
|
|
|
void CheckValid(void) {
|
|
DRIVERPARAM_CHECK_GE("iConfiguredCustomerCount", cur.iConfiguredCustomerCount, 1000);
|
|
DRIVERPARAM_CHECK_GE("iActiveCustomerCount", cur.iActiveCustomerCount, 1000);
|
|
DRIVERPARAM_CHECK_LE("iActiveCustomerCount", cur.iActiveCustomerCount, cur.iConfiguredCustomerCount);
|
|
DRIVERPARAM_CHECK_EQUAL("iConfiguredCustomerCount", cur.iConfiguredCustomerCount % 1000, 0);
|
|
DRIVERPARAM_CHECK_GE("iStartingCustomer", cur.iStartingCustomer, 1)
|
|
DRIVERPARAM_CHECK_EQUAL("iStartingCustomer", cur.iStartingCustomer % 1000, 1);
|
|
DRIVERPARAM_CHECK_EQUAL("iCustomerCount", cur.iCustomerCount % 1000, 0);
|
|
DRIVERPARAM_CHECK_LE("iCustomerCount", cur.iCustomerCount + cur.iStartingCustomer - 1,
|
|
cur.iConfiguredCustomerCount);
|
|
}
|
|
|
|
void CheckCompliant(void) {
|
|
CheckValid();
|
|
DRIVERPARAM_CHECK_GE("iConfiguredCustomerCount", cur.iConfiguredCustomerCount, 5000);
|
|
DRIVERPARAM_CHECK_GE("iActiveCustomerCount", cur.iActiveCustomerCount, 5000);
|
|
DRIVERPARAM_CHECK_EQUAL("iActiveCustomerCount", cur.iActiveCustomerCount, cur.iConfiguredCustomerCount);
|
|
DRIVERPARAM_CHECK_DEFAULT(iScaleFactor);
|
|
DRIVERPARAM_CHECK_DEFAULT(iDaysOfInitialTrades);
|
|
}
|
|
};
|
|
|
|
class CDriverGlobalSettings
|
|
: public CParametersWithDefaults<struct TDriverGlobalSettings, struct TDriverGlobalSettingsState> {
|
|
public:
|
|
CDriverGlobalSettings(TIdent iConfiguredCustomerCount, TIdent iActiveCustomerCount, INT32 iScaleFactor,
|
|
INT32 iDaysOfInitialTrades) {
|
|
Initialize();
|
|
|
|
cur.iConfiguredCustomerCount = iConfiguredCustomerCount;
|
|
cur.iActiveCustomerCount = iActiveCustomerCount;
|
|
cur.iScaleFactor = iScaleFactor;
|
|
cur.iDaysOfInitialTrades = iDaysOfInitialTrades;
|
|
|
|
CheckDefaults();
|
|
}
|
|
|
|
CDriverGlobalSettings() {
|
|
Initialize();
|
|
}
|
|
|
|
void InitializeDefaults(void) {
|
|
// NOTE: All of these parameters should match the default values hard-
|
|
// coded in src/EGenLoader.cpp via the variable names listed below,
|
|
// as these are the minimum build (and therefore run) values.
|
|
dft.iConfiguredCustomerCount = 5000; // iDefaultLoadUnitSize
|
|
dft.iActiveCustomerCount = 5000; // iDefaultLoadUnitSize
|
|
dft.iScaleFactor = 500; // iScaleFactor
|
|
dft.iDaysOfInitialTrades = 300; // iDaysOfInitialTrades
|
|
}
|
|
|
|
void CheckDefaults(void) {
|
|
state.iConfiguredCustomerCount = true;
|
|
state.iActiveCustomerCount = true;
|
|
state.iScaleFactor = (cur.iScaleFactor == dft.iScaleFactor);
|
|
state.iDaysOfInitialTrades = (cur.iDaysOfInitialTrades == dft.iDaysOfInitialTrades);
|
|
}
|
|
|
|
void CheckValid(void) {
|
|
DRIVERPARAM_CHECK_GE("iConfiguredCustomerCount", cur.iConfiguredCustomerCount, 1000);
|
|
DRIVERPARAM_CHECK_GE("iActiveCustomerCount", cur.iActiveCustomerCount, 1000);
|
|
DRIVERPARAM_CHECK_LE("iActiveCustomerCount", cur.iActiveCustomerCount, cur.iConfiguredCustomerCount);
|
|
DRIVERPARAM_CHECK_EQUAL("iConfiguredCustomerCount", cur.iConfiguredCustomerCount % 1000, 0);
|
|
}
|
|
|
|
void CheckCompliant(void) {
|
|
CheckValid();
|
|
DRIVERPARAM_CHECK_GE("iConfiguredCustomerCount", cur.iConfiguredCustomerCount, 5000);
|
|
DRIVERPARAM_CHECK_GE("iActiveCustomerCount", cur.iActiveCustomerCount, 5000);
|
|
DRIVERPARAM_CHECK_EQUAL("iActiveCustomerCount", cur.iActiveCustomerCount, cur.iConfiguredCustomerCount);
|
|
DRIVERPARAM_CHECK_DEFAULT(iScaleFactor);
|
|
DRIVERPARAM_CHECK_DEFAULT(iDaysOfInitialTrades);
|
|
}
|
|
};
|
|
|
|
class CDriverCESettings : public CParametersWithoutDefaults<struct TDriverCESettings> {
|
|
public:
|
|
CDriverCESettings(UINT32 UniqueId, RNGSEED TxnMixRNGSeed, RNGSEED TxnInputRNGSeed) {
|
|
cur.UniqueId = UniqueId;
|
|
cur.TxnMixRNGSeed = TxnMixRNGSeed;
|
|
cur.TxnInputRNGSeed = TxnInputRNGSeed;
|
|
}
|
|
|
|
CDriverCESettings(){};
|
|
|
|
void CheckValid(void) {
|
|
}
|
|
|
|
void CheckCompliant(void) {
|
|
}
|
|
};
|
|
|
|
class CDriverCEPartitionSettings
|
|
: public CParametersWithDefaults<struct TDriverCEPartitionSettings, struct TDriverCEPartitionSettingsState> {
|
|
public:
|
|
CDriverCEPartitionSettings(TIdent iMyStartingCustomerId, TIdent iMyCustomerCount, INT32 iPartitionPercent) {
|
|
Initialize();
|
|
|
|
cur.iMyStartingCustomerId = iMyStartingCustomerId;
|
|
cur.iMyCustomerCount = iMyCustomerCount;
|
|
cur.iPartitionPercent = iPartitionPercent;
|
|
|
|
CheckDefaults();
|
|
}
|
|
|
|
// Default constructor neccessary for CE instantiation in the
|
|
// non-partitioned case In thise case we set the current values to 0 to
|
|
// indicate that they are unused.
|
|
CDriverCEPartitionSettings() {
|
|
Initialize();
|
|
|
|
cur.iMyStartingCustomerId = 0;
|
|
cur.iMyCustomerCount = 0;
|
|
cur.iPartitionPercent = 0;
|
|
|
|
CheckDefaults();
|
|
}
|
|
|
|
void InitializeDefaults(void) {
|
|
dft.iMyStartingCustomerId = 1; // Spec 6.4.3.1: Minimum possible starting C_ID
|
|
dft.iMyCustomerCount = 5000; // Spec 6.4.3.1: Minimum partition size
|
|
dft.iPartitionPercent = 50; // Spec 6.4.3.1: Required partition percentage
|
|
}
|
|
|
|
void CheckDefaults(void) {
|
|
state.iPartitionPercent = (cur.iPartitionPercent == dft.iPartitionPercent);
|
|
}
|
|
|
|
void CheckValid(void) {
|
|
DRIVERPARAM_CHECK_BETWEEN("iPartitionPercent", cur.iPartitionPercent, 0, 100);
|
|
if (cur.iMyStartingCustomerId == 0 && cur.iMyCustomerCount == 0 && cur.iPartitionPercent == 0) {
|
|
// Partitioning Disabled:
|
|
// - in this case, the default constructor would have been used and
|
|
// all values
|
|
// are set to 0. This must be considered valid.
|
|
} else {
|
|
// Partitioning Enabled:
|
|
// Spec clause 6.4.3.1 has many requirements, these are the ones
|
|
// that we validate here:
|
|
// - minimum C_ID in a subrange is the starting C_ID for a LU
|
|
// - minimum C_ID size of a subrange is 5000
|
|
// - size of a subrange must be an integral multiple of LU
|
|
DRIVERPARAM_CHECK_EQUAL("iMyStartingCustomerId", cur.iMyStartingCustomerId % 1000, 1);
|
|
DRIVERPARAM_CHECK_GE("iMyCustomerCount", cur.iMyCustomerCount, 1000);
|
|
DRIVERPARAM_CHECK_EQUAL("iMyCustomerCount", cur.iMyCustomerCount % 1000, 0);
|
|
}
|
|
}
|
|
|
|
void CheckCompliant(void) {
|
|
CheckValid();
|
|
|
|
if (cur.iMyStartingCustomerId == 0 && cur.iMyCustomerCount == 0 && cur.iPartitionPercent == 0) {
|
|
// Partitioning Disabled
|
|
} else {
|
|
// - CE partition is used 50% of the time
|
|
DRIVERPARAM_CHECK_DEFAULT(iPartitionPercent);
|
|
}
|
|
}
|
|
};
|
|
|
|
class CDriverMEESettings : public CParametersWithoutDefaults<struct TDriverMEESettings> {
|
|
public:
|
|
CDriverMEESettings(UINT32 UniqueId, RNGSEED RNGSeed, RNGSEED TickerTapeRNGSeed, RNGSEED TradingFloorRNGSeed) {
|
|
cur.UniqueId = UniqueId;
|
|
cur.RNGSeed = RNGSeed;
|
|
cur.TickerTapeRNGSeed = TickerTapeRNGSeed;
|
|
cur.TradingFloorRNGSeed = TradingFloorRNGSeed;
|
|
}
|
|
|
|
CDriverMEESettings(){};
|
|
|
|
void CheckValid(void) {
|
|
}
|
|
|
|
void CheckCompliant(void) {
|
|
}
|
|
};
|
|
|
|
class CDriverDMSettings : public CParametersWithoutDefaults<struct TDriverDMSettings> {
|
|
public:
|
|
CDriverDMSettings(UINT32 UniqueId, RNGSEED RNGSeed) {
|
|
cur.UniqueId = UniqueId;
|
|
cur.RNGSeed = RNGSeed;
|
|
}
|
|
|
|
CDriverDMSettings(){};
|
|
|
|
void CheckValid(void) {
|
|
}
|
|
|
|
void CheckCompliant(void) {
|
|
}
|
|
};
|
|
|
|
typedef struct TDriverCETxnSettings {
|
|
CBrokerVolumeSettings BV_settings;
|
|
CCustomerPositionSettings CP_settings;
|
|
CMarketWatchSettings MW_settings;
|
|
CSecurityDetailSettings SD_settings;
|
|
CTradeLookupSettings TL_settings;
|
|
CTradeOrderSettings TO_settings;
|
|
CTradeUpdateSettings TU_settings;
|
|
|
|
CTxnMixGeneratorSettings TxnMixGenerator_settings;
|
|
|
|
bool IsValid(void) {
|
|
try {
|
|
CheckValid();
|
|
return true;
|
|
} catch (CCheckErr) {
|
|
throw;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool IsCompliant(void) {
|
|
try {
|
|
CheckCompliant();
|
|
return true;
|
|
} catch (CCheckErr) {
|
|
throw;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
void CheckValid(void) {
|
|
BV_settings.CheckValid();
|
|
CP_settings.CheckValid();
|
|
MW_settings.CheckValid();
|
|
SD_settings.CheckValid();
|
|
TL_settings.CheckValid();
|
|
TO_settings.CheckValid();
|
|
TU_settings.CheckValid();
|
|
TxnMixGenerator_settings.CheckValid();
|
|
}
|
|
|
|
void CheckCompliant(void) {
|
|
BV_settings.CheckCompliant();
|
|
CP_settings.CheckCompliant();
|
|
MW_settings.CheckCompliant();
|
|
SD_settings.CheckCompliant();
|
|
TL_settings.CheckCompliant();
|
|
TO_settings.CheckCompliant();
|
|
TU_settings.CheckCompliant();
|
|
TxnMixGenerator_settings.CheckCompliant();
|
|
}
|
|
} * PDriverCETxnSettings;
|
|
|
|
} // namespace TPCE
|
|
|
|
#endif //#ifndef DRIVER_PARAM_SETTINGS_H
|