CustomTrafficPattern::CustomTrafficPattern(int nodes,string injection_nodes_str) : TrafficPattern(nodes)
{
if(injection_nodes_str.empty()) {
for (int i=0; i<nodes; i++) _injection_nodes.push_back(i);
} else {
_injection_nodes = tokenize_int(injection_nodes_str);
}
}
vector<int> Configuration::GetIntArray(string const & field) const
{
string const param_str = GetStr(field);
return tokenize_int(param_str);
}
TrafficPattern * TrafficPattern::New(string const & pattern, int nodes,
Configuration const * const config)
{
string pattern_name;
string param_str;
size_t left = pattern.find_first_of('(');
if(left == string::npos) {
pattern_name = pattern;
} else {
pattern_name = pattern.substr(0, left);
size_t right = pattern.find_last_of(')');
if(right == string::npos) {
param_str = pattern.substr(left+1);
} else {
param_str = pattern.substr(left+1, right-left-1);
}
}
vector<string> params = tokenize_str(param_str);
TrafficPattern * result = NULL;
if(pattern_name == "bitcomp") {
result = new BitCompTrafficPattern(nodes);
} else if(pattern_name == "transpose") {
result = new TransposeTrafficPattern(nodes);
} else if(pattern_name == "bitrev") {
result = new BitRevTrafficPattern(nodes);
} else if(pattern_name == "shuffle") {
result = new ShuffleTrafficPattern(nodes);
} else if(pattern_name == "randperm") {
int perm_seed = -1;
if(params.empty()) {
if(config) {
if(config->GetStr("perm_seed") == "time") {
perm_seed = int(time(NULL));
cout << "SEED: perm_seed=" << perm_seed << endl;
} else {
perm_seed = config->GetInt("perm_seed");
}
} else {
cout << "Error: Missing parameter for random permutation traffic pattern: " << pattern << endl;
exit(-1);
}
} else {
perm_seed = atoi(params[0].c_str());
}
result = new RandomPermutationTrafficPattern(nodes, perm_seed);
} else if(pattern_name == "uniform") {
result = new UniformRandomTrafficPattern(nodes);
} else if(pattern_name == "background") {
vector<int> excludes = tokenize_int(params[0]);
result = new UniformBackgroundTrafficPattern(nodes, excludes);
} else if(pattern_name == "diagonal") {
result = new DiagonalTrafficPattern(nodes);
} else if(pattern_name == "asymmetric") {
result = new AsymmetricTrafficPattern(nodes);
} else if(pattern_name == "taper64") {
result = new Taper64TrafficPattern(nodes);
} else if(pattern_name == "bad_dragon") {
bool missing_params = false;
int k = -1;
if(params.size() < 1) {
if(config) {
k = config->GetInt("k");
} else {
missing_params = true;
}
} else {
k = atoi(params[0].c_str());
}
int n = -1;
if(params.size() < 2) {
if(config) {
n = config->GetInt("n");
} else {
missing_params = true;
}
} else {
n = atoi(params[1].c_str());
}
if(missing_params) {
cout << "Error: Missing parameters for dragonfly bad permutation traffic pattern: " << pattern << endl;
exit(-1);
}
result = new BadPermDFlyTrafficPattern(nodes, k, n);
} else if((pattern_name == "tornado") || (pattern_name == "neighbor") ||
(pattern_name == "badperm_yarc")) {
bool missing_params = false;
int k = -1;
if(params.size() < 1) {
if(config) {
k = config->GetInt("k");
} else {
missing_params = true;
}
} else {
k = atoi(params[0].c_str());
}
int n = -1;
if(params.size() < 2) {
if(config) {
n = config->GetInt("n");
} else {
missing_params = true;
}
} else {
n = atoi(params[1].c_str());
}
int xr = -1;
if(params.size() < 3) {
if(config) {
xr = config->GetInt("xr");
} else {
missing_params = true;
}
} else {
xr = atoi(params[2].c_str());
}
if(missing_params) {
cout << "Error: Missing parameters for digit permutation traffic pattern: " << pattern << endl;
exit(-1);
}
if(pattern_name == "tornado") {
result = new TornadoTrafficPattern(nodes, k, n, xr);
} else if(pattern_name == "neighbor") {
result = new NeighborTrafficPattern(nodes, k, n, xr);
} else if(pattern_name == "badperm_yarc") {
result = new BadPermYarcTrafficPattern(nodes, k, n, xr);
}
} else if(pattern_name == "hotspot") {
if(params.empty()) {
params.push_back("-1");
}
vector<int> hotspots = tokenize_int(params[0]);
for(size_t i = 0; i < hotspots.size(); ++i) {
if(hotspots[i] < 0) {
hotspots[i] = RandomInt(nodes - 1);
}
}
vector<int> rates;
if(params.size() >= 2) {
rates = tokenize_int(params[1]);
rates.resize(hotspots.size(), rates.back());
} else {
rates.resize(hotspots.size(), 1);
}
result = new HotSpotTrafficPattern(nodes, hotspots, rates);
} else {
cout << "Error: Unknown traffic pattern: " << pattern << endl;
exit(-1);
}
return result;
}
