void run_threaded_string_sends_0(size_t length, size_t numthreads) {
if (rmi.procid() == 1) {
rmi.full_barrier();
return;
}
timer ti;
std::cout << numthreads << " threaded " << SEND_LIMIT_PRINT <<" sends, "
<< length << " bytes\n";
ti.start();
size_t numsends = SEND_LIMIT / (length * numthreads);
size_t rd = rdtsc();
thread_group thrgrp;
for (size_t i = 0; i < numthreads; ++i) {
thrgrp.launch(boost::bind(&teststruct::perform_string_sends_0, this, length, numsends));
}
thrgrp.join();
size_t rd2 = rdtsc();
std::cout << (rd2 - rd) / (numthreads * numsends) << " cycles per call\n";
double t1 = ti.current_time();
rmi.dc().flush();
double t2 = ti.current_time();
rmi.full_barrier();
double t3 = ti.current_time();
print_res(t1,t2,t3);
}
/**
* Sets the newval to be the value associated with the key
*/
void set(const KeyType &key, const ValueType &newval) {
// who owns the data?
const size_t hashvalue = hasher(key);
const size_t owningmachine = hashvalue % rpc.numprocs();
// if it is me, set it
if (owningmachine == rpc.dc().procid()) {
lock.lock();
storage[hashvalue] = newval;
lock.unlock();
} else {
rpc.remote_call(owningmachine,
&dht<KeyType,ValueType>::set,
key, newval);
}
}
void run_short_sends_0() {
if (rmi.procid() == 1) {
rmi.full_barrier();
return;
}
timer ti;
std::cout << "Single Threaded " << SEND_LIMIT_PRINT << " sends, 4 integer blocks\n";
ti.start();
size_t numsends = SEND_LIMIT / (sizeof(size_t) * 4);
perform_short_sends_0(numsends);
double t1 = ti.current_time();
rmi.dc().flush();
double t2 = ti.current_time();
rmi.full_barrier();
double t3 = ti.current_time();
print_res(t1,t2,t3);
}
/**
* gets the value associated with a key.
* Returns (true, Value) if the entry is available.
* Returns (false, undefined) otherwise.
*/
std::pair<bool, ValueType> get(const KeyType &key) const {
// who owns the data?
const size_t hashvalue = hasher(key);
const size_t owningmachine = hashvalue % rpc.numprocs();
std::pair<bool, ValueType> retval;
// if it is me, we can return it
if (owningmachine == rpc.dc().procid()) {
lock.lock();
typename storage_type::const_iterator iter = storage.find(hashvalue);
retval.first = iter != storage.end();
if (retval.first) retval.second = iter->second;
lock.unlock();
} else {
retval = rpc.remote_request(owningmachine,
&dht<KeyType,ValueType>::get,
key);
}
return retval;
}
void run_threaded_short_pod_sends_0(size_t numthreads) {
if (rmi.procid() == 1) {
rmi.full_barrier();
return;
}
timer ti;
std::cout << numthreads << " threaded "<< SEND_LIMIT_PRINT <<" POD sends, 4 integers\n";
size_t numsends = SEND_LIMIT / (sizeof(size_t) * 4 * numthreads);
ti.start();
thread_group thrgrp;
for (size_t i = 0; i < numthreads; ++i) {
thrgrp.launch(boost::bind(&teststruct::perform_short_pod_sends_0, this, numsends));
}
thrgrp.join();
double t1 = ti.current_time();
rmi.dc().flush();
double t2 = ti.current_time();
rmi.full_barrier();
double t3 = ti.current_time();
print_res(t1,t2,t3);
}
void run_string_sends_0(size_t length) {
if (rmi.procid() == 1) {
rmi.full_barrier();
return;
}
timer ti;
size_t numsends = SEND_LIMIT / (length);
std::cout << "Single Threaded " << SEND_LIMIT_PRINT <<" sends, " << length << " bytes * "<< numsends << "\n";
ti.start();
size_t rd = rdtsc();
perform_string_sends_0(length, numsends);
size_t rd2 = rdtsc();
std::cout << "Completed in: " << ti.current_time() << " seconds\n";
std::cout << (rd2 - rd) / numsends << " cycles per call\n";
double t1 = ti.current_time();
rmi.dc().flush();
std::cout << "Flush in: " << ti.current_time() << " seconds\n";
double t2 = ti.current_time();
rmi.full_barrier();
std::cout << "Receive Complete in: " << ti.current_time() << " seconds\n";
double t3 = ti.current_time();
print_res(t1,t2,t3);
}
/**
* Get the owner of the key
*/
procid_t owner(const KeyType& key) const {
return hasher(key) % rpc.dc().numprocs();
}