bool test_feature()
{
{
std::unique_ptr<int[]> edata(new int[_rank]);
for (int i = 0; i < _rank; i++)
edata[i] = (i == 0) ? 0 : 1;
extent<_rank> e1(edata.get());
array<_type, _rank> src(e1);
if (src.get_extent() != e1)
{
return false;
}
// verify array extents are modified
for (int i = 0; i < _rank; i++)
{
if (edata[i] != src.get_extent()[i])
return false;
}
}
return true;
}
std::wstring evtcchartowstr(evt_t* e)
{
std::string edata((char*)e->data, e->data_len);
std::wstring wedata;
wedata.resize(e->data_len);
std::copy(edata.begin(), edata.end(), wedata.begin());
return wedata;
}
// test single round
bool test_1()
{
const unsigned char test_data[16]={0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef,0xfe,0xdc,0xba,0x98,0x76,0x54,0x32,0x10};
const unsigned char key[16]={0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef,0xfe,0xdc,0xba,0x98,0x76,0x54,0x32,0x10};
const unsigned char right_e_data[16]={0x68,0x1e,0xdf,0x34,0xd2,0x06,0x96,0x5e,0x86,0xb3,0xe9,0x4f,0x53,0x6e,0x42,0x46};
unsigned char c_data[16];
sm::sm4::sm4_crypt_data edata(16);
sm::sm4::sm4_data_writor cdata_writor(c_data,16);
sm::sm4::SM4 sm4(key);
sm4.crypt(sm::sm4::kSM4Encrypt,test_data,16,edata);
sm4.crypt(sm::sm4::kSM4Decrypt,edata.ptr(),edata.bytes(),cdata_writor);
bool c_data_ok=::memcmp(test_data,cdata_writor.ptr(),cdata_writor.has_writen())==0;
bool e_data_ok=::memcmp(edata.ptr(),right_e_data,edata.bytes())==0;
return ( c_data_ok && e_data_ok);
}
// test tread-safty
void crypt_func(sm::sm4::SM4* sm4,const unsigned char* data,size_t data_bytes,size_t loop,bool* satus)
{
sm::sm4::sm4_crypt_data edata(data_bytes);
sm::sm4::sm4_crypt_data cdata(data_bytes);
for (size_t i=0;i<loop;++i){
/*
if(i%(loop/10)==0 && i!=0)
std::cout<<"running, loop "<<i<<" of "<< loop<<std::endl;
*/
sm4->crypt(sm::sm4::kSM4Encrypt,data,data_bytes,edata);
sm4->crypt(sm::sm4::kSM4Decrypt,edata.ptr(),edata.bytes(),cdata);
if (::memcmp(data,cdata.ptr(),data_bytes)!=0){
std::cout<<"test failed, loop="<<i<< std::endl;
*satus=false;
return;
}
}
}
/////////////////////////////////////////////////////////////////////////
// Load the UAI file. Each factor as a different vertex
void loadUAIfile(graphlab::distributed_control& dc, graph_type& graph, string graph_file)
{
// Not sure why this is needed
dc.barrier();
// Open file
ifstream in(graph_file.c_str());
//CHECK(in.good(),"Could not open file: "+graph_file);
CHECK(in.good());
// Read type of network
string name;
in >> name;
//CHECK(name.compare("MARKOV")==0, "Only Markov networks are supported. Are you sure this is a typeUAI energy file?");
CHECK(name.compare("MARKOV")==0);
// Read size of graph
int nnodes, nfactors;
in >> nnodes;
//CHECK(nnodes>0, "No. of nodes can't be negative. Are you sure this is a typeUAI energy file?");
CHECK(nnodes>0);
// Read node cardinalities
vector<int> cardinalities(nnodes,0);
int cardinality_i, sum_of_cardinalities = 0;
for (int i = 0; i != nnodes; ++i)
{
in >> cardinality_i;
cardinalities[i] = cardinality_i;
sum_of_cardinalities += cardinality_i;
//cout << cardinalities[i] << " ";
//CHECK(in.good(), "Could not finish reading cardinalities. Are you sure this is a typeUAI energy file?");
CHECK(in.good());
}
// Read no. of factors
in >> nfactors;
//factor_size.resize(nfactors); factor_id.resize(nfactors);
vector<int> factor_size(nfactors,0); //vector<int> factor_id(nfactors,0);
vector< vector<int> > factor_memb; factor_memb.resize(nfactors);
int temp1, temp2;
// Loop and read factor members
for (int i=0; i!=nfactors; ++i)
{
in >> temp1;
factor_size[i] = temp1;
factor_memb[i].resize(temp1);
for (int j=0; j!=temp1; ++j)
{
in >> temp2;
factor_memb[i][j] = temp2;
}
//CHECK(in.good(), "Could not finish reading cardinalities. Are you sure this is a typeUAI energy file?");
CHECK(in.good());
}
if (opts.verbose > 0)
cout
<< "Finished Reading UAI-Preamble:"
<< " #Nodes = " << nnodes
<< ", #Factors = "<< nfactors
<< ", Average Cardinality = " << double(sum_of_cardinalities)/nfactors
<< "\n";
// Now read factor potentials
for (int i=0; i!=nfactors; ++i)
{
int cardprod; double potential_value; //, energy;
in >> cardprod;
vertex_data vdata;
vdata.nvars = factor_size[i];
if (vdata.nvars > 1) {
vdata.degree = vdata.nvars; // Factor degree.
}
vdata.cards.resize(factor_size[i]);
vdata.neighbors.resize(factor_size[i]);
vector<edge_data> edata(factor_size[i]);
int cardprod2 = 1;
for (int j=0; j!=factor_size[i]; ++j)
{
vdata.cards[j] = cardinalities[factor_memb[i][j]];
vdata.neighbors[j] = factor_memb[i][j]; // afm (check if this was intended!)
cardprod2 *= vdata.cards[j];
// Also create edge structs here
if (factor_size[i]>1)
{
edata[j].varid = factor_memb[i][j];
edata[j].card = cardinalities[edata[j].varid];
edata[j].multiplier_messages.setZero(edata[j].card);
edata[j].local_messages.setZero(edata[j].card);
}
}
//CHECK_EQ(cardprod, cardprod2, "Incorrectly sized factor");
CHECK_EQ(cardprod, cardprod2);
// Read factor potentials
vdata.potentials.resize(cardprod);
for (int k = 0; k != cardprod; ++k)
{
in >> potential_value;
//energy = Potential2Energy(potential_value);
vdata.potentials[k] = log10(potential_value);
}
//CHECK(in.good(), "Could not finish reading factor tables. Are you sure this is a typeUAI energy file?");
CHECK(in.good());
// allocate factors evenly to different machines.
if (i%dc.numprocs() != dc.procid())
continue;
// If all is well, add vertex and edges
graph.add_vertex(i,vdata);
if (factor_size[i] > 1) // if not a unary, add edges to unaries
for (int j=0; j!=factor_size[i]; ++j)
graph.add_edge(i,edata[j].varid,edata[j]);
if (opts.verbose > 1)
{
cout << "Machine #" << dc.procid() << ", Vertex Id = " << i
<< " with " << vdata.nvars << " variables.";
if (factor_size[i] > 1)
{
cout << ", Edges = ";
for (int j=0; j!=factor_size[i]; ++j)
cout << ", (" << i << "," << edata[j].varid << ")";
}
cout << "\n";
cout << "potential: " << vdata.potentials << "\n";
}
} // End of reading factors
dc.barrier();
} // end of loading UAI file
void Event::write(Xml& xml) const
{
switch(_type) {
case ME_NOTE:
xml.tagE(QString("note tick=\"%1\" channel=\"%2\" len=\"%3\" pitch=\"%4\" velo=\"%5\"")
.arg(_ontime).arg(_channel).arg(_duration).arg(_a).arg(_b));
break;
case ME_NOTEON:
xml.tagE(QString("note-on tick=\"%1\" channel=\"%2\" pitch=\"%3\" velo=\"%4\"")
.arg(_ontime).arg(_channel).arg(_a).arg(_b));
break;
case ME_NOTEOFF:
xml.tagE(QString("note-off tick=\"%1\" channel=\"%2\" pitch=\"%3\" velo=\"%4\"")
.arg(_ontime).arg(_channel).arg(_a).arg(_b));
break;
case ME_CONTROLLER:
if (_a == CTRL_PROGRAM) {
if ((_ontime == -1) && (_channel == 0)) {
xml.tagE(QString("program value=\"%1\"").arg(_b));
}
else {
xml.tagE(QString("program tick=\"%1\" channel=\"%2\" value=\"%3\"")
.arg(ontime()).arg(channel()).arg(_b));
}
}
else {
if ((ontime() == -1) && (channel() == 0)) {
xml.tagE(QString("controller ctrl=\"%1\" value=\"%2\"")
.arg(_a).arg(_b));
}
else {
xml.tagE(QString("controller tick=\"%1\" channel=\"%2\" ctrl=\"%3\" value=\"%4\"")
.arg(ontime()).arg(channel()).arg(_a).arg(_b));
}
}
break;
case ME_SYSEX:
xml.stag(QString("sysex tick=\"%1\" len=\"%2\"").arg(ontime()).arg(_len));
xml.dump(_len, _edata);
xml.etag();
break;
case ME_META:
switch(metaType()) {
case META_TRACK_NAME:
xml.tag(QString("TrackName tick=\"%1\"").arg(ontime()), QString((char*)(edata())));
break;
case META_LYRIC:
xml.tag(QString("Lyric tick=\"%1\"").arg(ontime()), QString((char*)(edata())));
break;
case META_KEY_SIGNATURE:
{
const char* keyTable[] = {
"Ces", "Ges", "Des", "As", "Es", "Bes", "F",
"C",
"G", "D", "A", "E", "B", "Fis", "Cis"
};
int key = (char)(_edata[0]) + 7;
if (key < 0 || key > 14) {
qDebug("bad key signature %d", key);
key = 0;
}
QString sex(_edata[1] ? "Minor" : "Major");
QString keyName(keyTable[key]);
xml.tag(QString("Key tick=\"%1\" key=\"%2\" sex=\"%3\"").arg(ontime()).arg(_edata[0]).arg(_edata[1]),
QString("%1 %2").arg(keyName).arg(sex));
}
break;
case META_TIME_SIGNATURE:
xml.tagE(QString("TimeSig tick=\"%1\" num=\"%2\" denom=\"%3\" metro=\"%4\" quarter=\"%5\"")
.arg(ontime())
.arg(int(_edata[0]))
.arg(int(_edata[1]))
.arg(int(_edata[2]))
.arg(int(_edata[3])));
break;
case META_TEMPO:
{
unsigned tempo = _edata[2] + (_edata[1] << 8) + (_edata[0] << 16);
xml.tagE(QString("Tempo tick=\"%1\" value=\"%2\"").arg(ontime()).arg(tempo));
}
break;
default:
xml.stag(QString("Meta tick=\"%1\" type=\"%2\" len=\"%3\" name=\"%4\"")
.arg(ontime()).arg(metaType()).arg(_len).arg(midiMetaName(metaType())));
xml.dump(_len, _edata);
xml.etag();
break;
}
break;
}
}
static int request(struct mg_connection *mc) {
size_t edata_size=0;
const char *edata_data;
char *free_buf = NULL;
if (mc->is_websocket) {
// This handler is called for each incoming websocket frame, one or more
// times for connection lifetime.
char *s = mc->content;
int sl = mc->content_len;
//printf("WEBSOCKET: len %d uri <%s>\n", sl, mc->uri);
if (sl == 0) {
//printf("----KA %d\n", mc->remote_port);
return MG_TRUE; // keepalive?
}
conn_t *c = rx_server_websocket(mc);
if (c == NULL) return MG_FALSE;
if (c->stop_data) return MG_FALSE;
s[sl]=0;
//printf("WEBSOCKET: %d <%s> ", sl, s);
nbuf_allocq(&c->w2a, s, sl);
if (mc->content_len == 4 && !memcmp(mc->content, "exit", 4)) {
//printf("----EXIT %d\n", mc->remote_port);
return MG_FALSE;
} else {
return MG_TRUE;
}
} else {
if (strcmp(mc->uri, "/") == 0) mc->uri = "index.html"; else
if (mc->uri[0] == '/') mc->uri++;
char *ouri = (char *) mc->uri;
char *uri = ouri;
bool free_uri = FALSE;
if (strncmp(ouri, "wrx/", 4) == 0) {
uri = (char *) &mc->uri[4];
} else {
user_iface_t *ui = find_ui(mc->local_port);
// should never not find match since we only listen to ports in ui table
assert(ui);
asprintf(&uri, "%s/%s", ui->name, ouri);
free_uri = TRUE;
}
//printf("---- HTTP: uri %s (%s)\n", ouri, uri);
// try as file from in-memory embedded data
edata_data = edata(uri, &edata_size, &free_buf);
// try as request from browser
if (!edata_data) {
free_buf = (char*) wrx_malloc("req", NREQ_BUF);
edata_data = rx_server_request(mc, free_buf, &edata_size); // mc->uri is ouri without ui->name prefix
if (!edata_data) { wrx_free("req", free_buf); free_buf = NULL; }
}
if (!edata_data) {
printf("unknown URL: %s (%s) %s\n", ouri, uri, mc->query_string);
return MG_FALSE;
}
// for index.html process %[substitution]
if (strcmp(ouri, "index.html") == 0) {
static bool index_init;
static char *index_html, *index_buf;
static size_t index_size;
#ifdef EDATA_EMBED
if (!index_init) { // only have to do once
#else
if (true) { // file might change anytime during development
#endif
if (!index_buf) index_buf = (char*) wrx_malloc("index_buf", edata_size*3/2);
char *cp = (char*) edata_data, *np = index_buf, *pp;
int i, cl, sl, nl=0, pl;
for (cl=0; cl < edata_size;) {
if (*cp == '%' && *(cp+1) == '[') {
cp += 2; cl += 2; pp = cp; pl = 0;
while (*cp != ']' && cl < edata_size) { cp++; cl++; pl++; }
cp++; cl++;
for (i=0; i < ARRAY_LEN(index_html_params); i++) {
index_html_params_t *ip = &index_html_params[i];
if (strncmp(pp, ip->param, pl) == 0) {
sl = strlen(ip->value);
strcpy(np, ip->value); np += sl;
break;
}
}
if (i == ARRAY_LEN(index_html_params)) {
// not found, put back original
strcpy(np, "%["); np += 2;
strncpy(np, pp, pl); np += pl;
*np++ = ']';
}
} else {
*np++ = *cp++; cl++;
}
}
index_html = index_buf;
index_size = np - index_buf;
index_init = true;
}
edata_data = index_html;
edata_size = index_size;
}
//printf("DATA: %s %d ", mc->uri, (int) edata_size);
mg_send_header(mc, "Content-Type", mg_get_mime_type(mc->uri, "text/plain"));
mg_send_data(mc, edata_data, edata_size);
if (free_uri) free(uri);
if (free_buf) wrx_free("req", free_buf);
http_bytes += edata_size;
return MG_TRUE;
}
}
static int ev_handler(struct mg_connection *mc, enum mg_event ev) {
int r;
//printf("ev_handler %d:%d len %d ", mc->local_port, mc->remote_port, (int) mc->content_len);
if (ev == MG_REQUEST) {
//printf("MG_REQUEST: URI:%s query:%s\n", mc->uri, mc->query_string);
r = request(mc);
//printf("\n");
return r;
} else
if (ev == MG_AUTH) {
//printf("MG_AUTH\n");
return MG_TRUE;
} else {
//printf("MG_OTHER\n");
return MG_FALSE;
}
}
/////////////////////////////////////////////////////////////////////////
// Load the UAI file. Each factor as a different vertex
void loadUAIfile(graphlab::distributed_control& dc, graph_type& graph, string graph_file, int& nodes)
{
// Not sure why this is needed
dc.barrier();
// Open file
ifstream in(graph_file.c_str());
//CHECK(in.good(),"Could not open file: "+graph_file);
CHECK(in.good());
// Read type of network
string name;
in >> name;
//CHECK(name.compare("MARKOV")==0, "Only Markov networks are supported. Are you sure this is a typeUAI energy file?");
CHECK(name.compare("MARKOV")==0);
// Read size of graph
int nnodes, nfactors;
in >> nnodes;
nodes = nnodes;
//CHECK(nnodes>0, "No. of nodes can't be negative. Are you sure this is a typeUAI energy file?");
CHECK(nnodes>0);
// Read node cardinalities
vector<int> cardinalities(nnodes,0);
int cardinality_i, sum_of_cardinalities = 0;
for (int i = 0; i != nnodes; ++i)
{
in >> cardinality_i;
cardinalities[i] = cardinality_i;
sum_of_cardinalities += cardinality_i;
//CHECK(in.good(), "Could not finish reading cardinalities. Are you sure this is a typeUAI energy file?");
CHECK(in.good());
}
int vid = 0;
if(opts.algorithm != 0){
for(int i = 0; i < nnodes; i++){ //temporary .. put condition
vertex_data vdata;
vdata.factor_type = VAR;
vdata.nvars = 1;
vdata.cards.resize(1, cardinalities[i]);
vdata.potentials.setZero(cardinalities[i]);
vdata.beliefs.setConstant(cardinalities[i], 0.5);
graph.add_vertex(vid, vdata);
vid++;
}
}
// Read no. of factors
in >> nfactors;
//factor_size.resize(nfactors); factor_id.resize(nfactors);
vector<int> factor_size(nfactors,0); //vector<int> factor_id(nfactors,0);
vector< vector<int> > factor_memb; factor_memb.resize(nfactors);
int temp1, temp2;
// Loop and read factor members
for (int i=0; i!=nfactors; ++i)
{
in >> temp1;
factor_size[i] = temp1;
factor_memb[i].resize(temp1);
for (int j=0; j!=temp1; ++j)
{
in >> temp2;
factor_memb[i][j] = temp2;
}
//CHECK(in.good(), "Could not finish reading cardinalities. Are you sure this is a typeUAI energy file?");
CHECK(in.good());
}
if (opts.verbose > 1)
cout
<< "Finished Reading UAI-Preamble:"
<< " #Nodes = " << nnodes
<< ", #Factors = "<< nfactors
<< ", Average Cardinality = " << double(sum_of_cardinalities)/nfactors
<< "\n";
// Now read factor potentials
for (int i=0; i!=nfactors; ++i)
{
int cardprod; double potential_value; //, energy;
in >> cardprod;
vertex_data vdata;
vdata.nvars = factor_size[i];
if (vdata.nvars > 1) {
vdata.degree = vdata.nvars; // Factor degree.
vdata.factor_type = DENSE;
}
else {
vdata.degree = 1; // Factor degree.
vdata.factor_type = XOR;
}
vdata.cards.resize(factor_size[i]);
vdata.neighbors.resize(factor_size[i]);
vector<edge_data> edata(factor_size[i]);
vector<int> varid(factor_size[i]);
vector<int> card(factor_size[i]);
int cardprod2 = 1;
for (int j=0; j!=factor_size[i]; ++j)
{
vdata.cards[j] = cardinalities[factor_memb[i][j]];
vdata.neighbors[j] = factor_memb[i][j]; // afm (check if this was intended!)
cardprod2 *= vdata.cards[j];
// Also create edge structs here
//if (factor_size[i]>1)
// {
varid[j] = factor_memb[i][j];
card[j] = cardinalities[varid[j]];
edata[j].multiplier_messages.setZero(card[j]);
edata[j].local_messages.setZero(card[j]);
edata[j].potentials.setZero(card[j]);
// }
}
//CHECK_EQ(cardprod, cardprod2, "Incorrectly sized factor");
CHECK_EQ(cardprod, cardprod2);
// Read factor potentials
vdata.potentials.resize(cardprod);
vdata.beliefs.resize(cardprod);
int x_offset = 0;
for(int x=0; x< vdata.nvars; x++){
for(int y=0; y<vdata.cards[x]; y++){
vdata.beliefs[x_offset+y] = 1.0/vdata.cards[x];
}
x_offset += vdata.cards[x];
}
vdata.factor_beliefs.setConstant(cardprod, 1.0/cardprod);
for (int k = 0; k != cardprod; ++k)
{
in >> potential_value;
//energy = Potential2Energy(potential_value);
vdata.potentials[k] = log10(potential_value) ;
}
//CHECK(in.good(), "Could not finish reading factor tables. Are you sure this is a typeUAI energy file?");
CHECK(in.good());
vdata.potentials.maxCoeff(&vdata.best_configuration);
// allocate factors evenly to different machines.
if (i%dc.numprocs() != dc.procid())
continue;
// If all is well, add vertex and edge
graph.add_vertex(vid ,vdata);
if (factor_size[i] > 1 || opts.algorithm > 0) // if not a unary, add edges to unaries
for (int j=0; j!=factor_size[i]; ++j)
graph.add_edge(vid,varid[j],edata[j]);
//after adding everything increment vertex id
vid++;
if (opts.verbose > 1)
{
cout << "Machine #" << dc.procid() << ", Vertex Id = " << i
<< " with " << vdata.nvars << " variables.";
if (factor_size[i] > 1)
{
cout << ", Edges = ";
for (int j=0; j!=factor_size[i]; ++j)
cout << ", (" << i << "," << varid[j] << ")";
}
cout << "\n";
cout << "potential: " << vdata.potentials << "\n";
}
} // End of reading factors
dc.barrier();
} // end of loading UAI file
