Java Local Cache Outperformed C++ Local Cache in 3.6.1

Question

Currently I'm using same local cache configuration to publish 10000 record of a portable object and retrieve same item few times from both Java and c++ client with oracle coherence 3.6.1 version. I'm using linux x86 version for both java and c++.
Results from Java : 3 Micro Seconds (best Case), 4-5 Micro Seconds (Average Case)
Results from C++ : 7 Micro Seconds, 8-9 Mirco Seconds (Average Case)
When we have local cache for both Java and C++ data retrival latency ideally should be same. But I was able to witness 4 Mirco Second lagging in c++. Is there any sort of c++ configuration which I can improve the perfromance to reach at least 4-5 Micro Seconds.
My local cache configuration is as follows.
<local-scheme>
<scheme-name>local-example</scheme-name>
</local-scheme>
So in underneath coherence implementation it uses Safe HashMap as the default (As the documentation). Please let me know if i'm doing something wrong?

Answer 1

Hi Dave,
I have append my c++ sample code for reference.
-------------- Main class -------------------
#include "coherence/lang.ns"
#include "coherence/net/CacheFactory.hpp"
#include "coherence/net/NamedCache.hpp"
#include <ace/High_Res_Timer.h>
#include <ace/Sched_Params.h>
#include "Order.hpp"
#include "Tokenizer.h"
#include <iostream>
#include <sstream>
#include <string>
#include <fstream>
using namespace coherence::lang;
using coherence::net::CacheFactory;
using coherence::net::NamedCache;
Order::View readOrder(String::View);
void createCache(std::string, NamedCache::Handle&, std::string, std::string&, std::string, std::string);
void readCache(NamedCache::Handle&, std::string, std::string&, std::string, std::string, std::string);
static int globalOrderIndex = 1;
int main(int argc, char** argv) {
try {
String::View vsCacheName;
std::string input;
std::ifstream infile;
std::string comment = "#";
infile.open("test-data.txt");
size_t found;
std::string result;
while (!infile.eof()) {
getline(infile, input);
if (input.empty())
continue;
found = input.rfind(comment);
if (found != std::string::npos)
continue;
Tokenizer str(input);
std::vector<std::string> tokens = str.split();
vsCacheName = tokens.at(0);
NamedCache::Handle hCache = CacheFactory::getCache(vsCacheName);
std::string itemCountList = tokens.at(1);
std::string searchCount = tokens.at(2);
std::string skipFirst = tokens.at(3);
std::string searchValue = tokens.at(4);
Tokenizer str1(itemCountList);
str1.setDelimiter(",");
std::vector<std::string> tokens1 = str1.split();
for (int x = 0; x < tokens1.size(); x++) {
std::string count = tokens1.at(x);
std::string result;
createCache(count, hCache, searchCount, result, vsCacheName, skipFirst);
sleep(1);
readCache(hCache, searchCount, result, skipFirst, count, searchValue);
std::cout << result << std::endl;
infile.close();
} catch (const std::exception& e) {
std::cerr << e.what() << std::endl;
Order::View readOrder(String::View aotag) { 
globalOrderIndex++;
return Order::create(aotag);
void createCache(std::string count, NamedCache::Handle& hCache, std::string searchIndex,
std::string& result, std::string cacheName, std::string skipValue) {
int totalRounds = atoi(count.c_str());
int search = atoi(searchIndex.c_str());
int skipFirstData = atoi(skipValue.c_str());
bool skipFirst = skipFirstData == 1 ? true : false;
int loop_count = skipFirstData == 1 ? search + 1 : search;
if (totalRounds == 0)
return;
ACE_hrtime_t average(0);
ACE_High_Res_Timer* tm = new ACE_High_Res_Timer();
ACE_hrtime_t nstime(0);
for (int x = 0; x <1; x++) {
tm->start();
for (int y = 0; y < totalRounds; y++) {
std::stringstream out;
out << globalOrderIndex;
String::View aotag = out.str();
Order::View order = readOrder(aotag);
hCache->put(aotag, order);
tm->stop();
tm->elapsed_time(nstime);
sleep(1);
if (x > 0 || !skipFirst) // skipping first write because it is an odd result
average += nstime;
tm->reset();
delete tm;
double totalTimetoAdd = average / (1 * 1000);
double averageOneItemAddTime = (average / (1 * totalRounds * 1000));
std::stringstream out;
out << totalTimetoAdd;
std::string timeToAddAll = out.str();
std::stringstream out1;
out1 << averageOneItemAddTime;
std::string timetoAddOne = out1.str();
result.append("------------- Test ");
result += cacheName;
result += " with ";
result += count;
result += " -------------\n";
result += "Time taken to publish data: ";
result += (timeToAddAll);
result += " us";
result += "\n";
result += "Time taken to publish one item: ";
result += (timetoAddOne);
result += " us\n";
void readCache(NamedCache::Handle& hCache, std::string searchCount,
std::string& result, std::string skipValue, std::string countVal, std::string searchValue) {
int skipData = atoi(skipValue.c_str());
bool skipFirst = skipData == 1 ? true : false;
int count = atoi(countVal.c_str());
String::View vsName = searchValue.c_str();
ACE_hrtime_t average(0);
int search = atoi(searchCount.c_str());
int loop_count = skipData == 1 ? search + 1 : search;
ACE_High_Res_Timer* tm = new ACE_High_Res_Timer();
ACE_hrtime_t nstime(0);
ACE_hrtime_t best_time(10000000);
bool isSaturated = true;
int saturatedValue = 0;
for (int x = 0; x < loop_count; x++) {
tm->start();
Order::View vInfo = cast<Order::View>(hCache->get(vsName));
tm->stop();
tm->elapsed_time(nstime);
if (x>0 || !skipFirst){
average += nstime;
if(nstime < best_time) {           
best_time = nstime;
if(isSaturated){
saturatedValue = x+1;
} else {
isSaturated = false;
std::cout << nstime << std::endl;
vInfo = NULL;
tm->reset();
Order::View vInfo = cast<Order::View>(hCache->get(vsName));
if(vInfo == NULL)
std::cout << "No info available" << std::endl;
// if(x%1000==0)
// sleep(1);
delete tm;
double averageRead = (average / (search * 1000));
double bestRead = ((best_time)/1000);
std::stringstream out1;
out1 << averageRead;
std::string timeToRead = out1.str();
std::stringstream out2;
out2 << bestRead;
std::stringstream out3;
out3 << saturatedValue;
result += "Average readtime: ";
result += (timeToRead);
result += " us, best time: ";
result += (out2.str());
result += " us, saturated index: ";
result += (out3.str());
result += " \n";
----------------- Order.hpp ---------------
#ifndef ORDER_INFO_HPP
#define ORDER_INFO_HPP
#include "coherence/lang.ns"
using namespace coherence::lang;
class Order : public cloneable_spec<Order> {
// ----- constructors ---------------------------------------------------
friend class factory<Order>;
public:
virtual size_t hashCode() const {
return size_t(&m_aotag);
virtual void toStream(std::ostream& out) const {
out << "Order("
<< "Aotag=" << getAotag()
<< ')';
virtual bool equals(Object::View that) const {
if (instanceof<Order::View > (that)) {
Order::View vThat = cast<Order::View > (that);
return Object::equals(getAotag(), vThat->getAotag())
return false;
protected:
Order(String::View aotag) : m_aotag(self(), aotag) {}
Order(const Order& that) : super(that), m_aotag(self(), that.m_aotag) {}
// ----- accessors ------------------------------------------------------
public:
virtual String::View getAotag() const {
return m_aotag;
// ----- data members ---------------------------------------------------
private:
const MemberView<String> m_aotag;
#endif // ORDER_INFO_HPP
----------- OrderSerializer.cpp -------------
#include "coherence/lang.ns"
#include "coherence/io/pof/PofReader.hpp"
#include "coherence/io/pof/PofWriter.hpp"
#include "coherence/io/pof/SystemPofContext.hpp"
#include "coherence/io/pof/PofSerializer.hpp"
#include "Order.hpp"
using namespace coherence::lang;
using coherence::io::pof::PofReader;
using coherence::io::pof::PofWriter;
using coherence::io::pof::PofSerializer;
class OrderSerializer: public class_spec<OrderSerializer,extends<Object>,implements<PofSerializer> > {
friend class factory<OrderSerializer>;
protected:
OrderSerializer(){
public: // PofSerializer interface
virtual void serialize(PofWriter::Handle hOut, Object::View v) const {
Order::View order = cast<Order::View > (v);
hOut->writeString(0, order->getAotag());
hOut->writeRemainder(NULL);
virtual Object::Holder deserialize(PofReader::Handle hIn) const {
String::View aotag = hIn->readString(0);
hIn->readRemainder();
return Order::create(aotag);
COH_REGISTER_POF_SERIALIZER(1001, TypedBarrenClass<Order>::create(), OrderSerializer::create());
-----------------Tokenizer.h--------
#ifndef TOKENIZER_H
#define TOKENIZER_H
#include <string>
#include <vector>
// default delimiter string (space, tab, newline, carriage return, form feed)
const std::string DEFAULT_DELIMITER = " \t\v\n\r\f";
class Tokenizer
public:
// ctor/dtor
Tokenizer();
Tokenizer(const std::string& str, const std::string& delimiter=DEFAULT_DELIMITER);
~Tokenizer();
// set string and delimiter
void set(const std::string& str, const std::string& delimiter=DEFAULT_DELIMITER);
void setString(const std::string& str); // set source string only
void setDelimiter(const std::string& delimiter); // set delimiter string only
std::string next(); // return the next token, return "" if it ends
std::vector<std::string> split(); // return array of tokens from current cursor
protected:
private:
void skipDelimiter(); // ignore leading delimiters
bool isDelimiter(char c); // check if the current char is delimiter
std::string buffer; // input string
std::string token; // output string
std::string delimiter; // delimiter string
std::string::const_iterator currPos; // string iterator pointing the current position
#endif // TOKENIZER_H
--------------- Tokenizer.cpp -------------
#include "Tokenizer.h"
Tokenizer::Tokenizer() : buffer(""), token(""), delimiter(DEFAULT_DELIMITER)
currPos = buffer.begin();
Tokenizer::Tokenizer(const std::string& str, const std::string& delimiter) : buffer(str), token(""), delimiter(delimiter)
currPos = buffer.begin();
Tokenizer::~Tokenizer()
void Tokenizer::set(const std::string& str, const std::string& delimiter)
this->buffer = str;
this->delimiter = delimiter;
this->currPos = buffer.begin();
void Tokenizer::setString(const std::string& str)
this->buffer = str;
this->currPos = buffer.begin();
void Tokenizer::setDelimiter(const std::string& delimiter)
this->delimiter = delimiter;
this->currPos = buffer.begin();
std::string Tokenizer::next()
if(buffer.size() <= 0) return ""; // skip if buffer is empty
token.clear(); // reset token string
this->skipDelimiter(); // skip leading delimiters
// append each char to token string until it meets delimiter
while(currPos != buffer.end() && !isDelimiter(*currPos))
token += *currPos;
++currPos;
return token;
void Tokenizer::skipDelimiter()
while(currPos != buffer.end() && isDelimiter(*currPos))
++currPos;
bool Tokenizer::isDelimiter(char c)
return (delimiter.find(c) != std::string::npos);
std::vector<std::string> Tokenizer::split()
std::vector<std::string> tokens;
std::string token;
while((token = this->next()) != "")
tokens.push_back(token);
return tokens;
I'm really concerned about the performance. 1 Micro seconds is very much valuable for me. If you could reduce it to 5 micro seconds then it would be a great help for me. I'm building above code by following release arguments.
"g++ -Wall -ansi -m32 -O3"
Following file is my test script
------------ test-data.txt ---------------
#cache type - data load - read attempts - skip first - read value
local-orders 10000 5 1 1
# dist-extend 1,100,10000 5 1 1
# repl-extend 1,100,10000 5 1 1
You can uncomment one by one and test different caches with different loads.
Thanks for the reply
sura
Edited by: sura on 23-Jun-2011 18:49
Edited by: sura on 23-Jun-2011 19:35
Edited by: sura on 23-Jun-2011 19:53