static void
formatUnknownContentLength(char* buf, PRUint32 len, PRUint32 bytesReceived, PRUint32 elapsed)
{
char rate[32];
*rate = 0;
// the transfer rate
double bytes_per_sec = 0;
if (elapsed > 0)
bytes_per_sec = ((double) bytesReceived) / ((double) elapsed);
formatRate(rate, sizeof(rate), bytes_per_sec);
// the number of bytes received
char bytes_received[32];
if (bytesReceived < KILOBYTE)
PR_snprintf(bytes_received, sizeof(bytes_received),
XP_GetString(XP_THERMO_UH),
bytesReceived, IS_PLURAL(bytesReceived));
else
PR_snprintf(bytes_received, sizeof(bytes_received),
XP_GetString(XP_THERMO_KBYTE_FORMAT),
bytesReceived / KILOBYTE);
if (*rate) {
/* "%s read (at %s)" */
PR_snprintf(buf, len, XP_GetString(XP_THERMO_PERCENT_RATE_FORM), bytes_received, rate);
}
else {
PR_snprintf(buf, len, XP_GetString(XP_THERMO_RAW_COUNT_FORM), bytes_received);
}
}
void benchmark(autoserial::ISerializable *object, int runs)
{
autoserial::OpaqueObject o;
o.set(object);
Size size = o.getSize();
std::cout << "Benching " << object->getTypeNameV() << " of " << formatSize(size) << std::endl;
{
// With alloaction + deallocation (closer to what happens in reality)
double st = Timer::get();
for (int i=0; i < runs; ++i)
{
autoserial::OpaqueObject obj;
obj.set(object);
}
double t = Timer::get()-st;
std::cout << "Serialization in " << t/runs << " ms" << std::endl;
std::cout << " Serialization including (de)allocation: " << formatRate(t, size, runs) << std::endl;
}
{
// With alloaction + deallocation (closer to what happens in reality)
double st = Timer::get();
for (int i=0; i < runs; ++i)
{
FLUSH();
autoserial::OpaqueObject obj;
obj.set(object);
}
double t = Timer::get()-st - flushTime*runs;
std::cout << "Serialization in " << t/runs << " ms" << std::endl;
std::cout << " Serialization including (de)allocation: " << formatRate(t, size, runs) << std::endl;
}
{
// Deserialization+deallocation
double st = Timer::get();
for (int i=0; i < runs; ++i)
{
autoserial::ISerializable *obj = o.get();
delete obj;
}
double t = Timer::get()-st;
std::cout << "DESerialization in " << t/runs << " ms" << std::endl;
std::cout << " Deserialization including (de)allocation: " << formatRate(t, size, runs) << std::endl;
}
{
// Deserialization+deallocation
double st = Timer::get();
for (int i=0; i < runs; ++i)
{
FLUSH();
autoserial::ISerializable *obj = o.get();
delete obj;
}
double t = Timer::get()-st - flushTime*runs;
std::cout << "DESerialization in " << t/runs << " ms" << std::endl;
std::cout << " Deserialization including (de)allocation: " << formatRate(t, size, runs) << std::endl;
}
{
// Comparison
autoserial::ISerializable *obj = o.get();
int count = 0;
double st = Timer::get();
for (int i=0; i < runs; ++i)
{
FLUSH();
if (!obj->equals(object))
count++;
}
double t = Timer::get()-st - flushTime*runs;
std::cout << " " << count << " Comparison time: " << formatRate(t, size, runs) << std::endl;
}
}
static void
formatKnownContentLength(char* buf,
PRUint32 len,
PRUint32 bytesReceived,
PRUint32 contentLength,
PRUint32 elapsed)
{
char rate[32];
*rate = 0;
// the transfer rate
double bytes_per_sec = 0;
if (elapsed > 0)
bytes_per_sec = ((double) bytesReceived) / ((double) elapsed);
formatRate(rate, sizeof(rate), bytes_per_sec);
// format the content length
char length[32];
*length = 0;
if (contentLength < KILOBYTE)
PR_snprintf(length, sizeof(length), XP_GetString(XP_THERMO_BYTE_FORMAT), contentLength);
else
PR_snprintf(length, sizeof(length), XP_GetString(XP_THERMO_KBYTE_FORMAT), contentLength / KILOBYTE);
// the percentage complete
char percent[32];
PRUint32 p = (bytesReceived * 100) / contentLength;
if (p >= 100 && bytesReceived != contentLength)
p = 99;
PR_snprintf(percent, sizeof(percent), XP_GetString(XP_THERMO_PERCENTAGE_FORMAT), p);
// the amount of time remaining
char tleft[32];
*tleft = 0;
if (bytes_per_sec >= KILOBYTE && elapsed >= ENOUGH_TIME_TO_GUESS) {
PRUint32 secs_left =
(PRUint32) (((double) (contentLength - bytesReceived)) / bytes_per_sec);
if (secs_left >= HOUR) {
PR_snprintf(tleft, sizeof(tleft),
XP_GetString(XP_THERMO_HOURS_FORMAT),
secs_left / HOUR,
(secs_left / MINUTE) % MINUTE,
secs_left % MINUTE);
}
else if (secs_left >= MINUTE) {
PR_snprintf(tleft, sizeof(tleft),
XP_GetString(XP_THERMO_MINUTES_FORMAT),
secs_left / MINUTE,
secs_left % MINUTE);
}
else if (secs_left > 0) {
PR_snprintf(tleft, sizeof(tleft),
XP_GetString(XP_THERMO_SECONDS_FORMAT),
secs_left,
IS_PLURAL(secs_left));
}
}
if (*tleft) {
/* "%s of %s (at %s, %s remaining)" */
PR_snprintf(buf, len,
XP_GetString(XP_THERMO_RATE_REMAINING_FORM),
percent, length, rate, tleft);
}
else if (*rate) {
/* "%s of %s (at %s)" */
PR_snprintf(buf, len,
XP_GetString(XP_THERMO_RATE_FORM),
percent, length, rate);
}
else {
/* "%s of %s" */
PR_snprintf(buf, len,
XP_GetString(XP_THERMO_PERCENT_FORM),
percent, length);
}
}
int main(int argc, char *argv[])
{
std::cout << "========= Benchmarking autoserial =========" << std::endl;
std::cout << " All times are in seconds " << std::endl;
// Compute rough memory bandwidth
{
#define bufsize 100000000
int iter = 100;
char *buf1 = new char[bufsize];
char *buf2 = new char[bufsize];
// Touch the memory
memcpy(buf1, buf2, bufsize*sizeof(char));
double st = Timer::get();
for (int i = 0; i < iter; ++i)
memcpy(buf1, buf2, bufsize*sizeof(char));
double t = Timer::get() - st;
std::cout << "Memory bandwidth (large memcpy): " << formatRate(t, bufsize, iter) << std::endl;
st = Timer::get();
for (int i = 0; i < iter; ++i)
memset(buf1, 0, bufsize*sizeof(char));
t = Timer::get() - st;
std::cout << "Memory bandwidth (large memset): " << formatRate(t, bufsize, iter) << std::endl;
st = Timer::get();
int count = 0;
for (int i = 0; i < iter; ++i)
count += memcmp(buf1, buf2, bufsize*sizeof(char));
t = Timer::get() - st;
std::cout << "Memory bandwidth (large memcmp): " << formatRate(t, bufsize, iter) << " " << count << std::endl;
}
// Compute rough memory bandwidth
{
#undef bufsize
#define bufsize 100
int iter = 100000000;
char *buf1 = new char[bufsize];
char *buf2 = new char[bufsize];
// Touch the memory
memcpy(buf1, buf2, bufsize*sizeof(char));
double st = Timer::get();
for (int i = 0; i < iter; ++i)
memcpy(buf1, buf2, bufsize*sizeof(char));
double t = Timer::get() - st;
std::cout << "Memory bandwidth (large memcpy): " << formatRate(t, bufsize, iter) << std::endl;
st = Timer::get();
for (int i = 0; i < iter; ++i)
memset(buf1, 0, bufsize*sizeof(char));
t = Timer::get() - st;
std::cout << "Memory bandwidth (large memset): " << formatRate(t, bufsize, iter) << std::endl;
st = Timer::get();
int count = 0;
for (int i = 0; i < iter; ++i)
count += memcmp(buf1, buf2, bufsize*sizeof(char));
t = Timer::get() - st;
std::cout << "Memory bandwidth (large memcmp): " << formatRate(t, bufsize, iter) << " " << count << std::endl;
}
// Initialize flushBuffer, to be read after every serialization to flush the cache
flushBuffer = (int*)malloc(flushBufferSize);
memset(flushBuffer, 0, flushBufferSize);
// Get reference time, to be subtracted to each measurement
flushTime = Timer::get();
for (int i=0; i<100; ++i)
FLUSH();
flushTime = (Timer::get()-flushTime)/100;
// Define various types of serializable objects
{
IntDouble d(0, 1.3);
benchmark(&d, 1000);
}
{
int a[] = {10, 100, 1000, 10000};
for (size_t i = 0; i<sizeof(a)/sizeof(int); ++i)
{
IntBuffer b(a[i]);
benchmark(&b, 1000);
}
}
{
Misc m;
benchmark(&m, 10000);
}
/* {
MiscBuffer mb(100);
}
*/
{
int a[] = {10, 100, 1000, 10000};
for (size_t i = 0; i<sizeof(a)/sizeof(int); ++i)
{
autoserial::internal::Buffer<Misc> b;
b.resize(a[i]);
benchmark(&b, 100000/a[i]);
}
}
{
int a[] = {10, 100, 1000, 10000};
for (size_t i = 0; i<sizeof(a)/sizeof(int); ++i)
{
StdVector s(a[i]);
benchmark(&s, 1000);
}
}
{
int a[] = {10, 100, 1000, 10000};
for (size_t i = 0; i<sizeof(a)/sizeof(int); ++i)
{
MapOfIntBuffers m(a[i]);
benchmark(&m, 1000/a[i]);
}
}
{
int a[] = {10, 100, 1000, 10000};
for (size_t i = 0; i<sizeof(a)/sizeof(int); ++i)
{
LinkedList l(a[i]);
benchmark(&l, 1000000/a[i]);
}
}
return 0;
}
