void put(K key, T data) {
LRUCacheEntry<K,T>* node = _mapping[key];
if (node) {
// refresh the link list
detach(node);
node->data = data;
attach(node);
} else {
if ( _freeEntries.empty() ) {
node = tail->prev;
detach(node);
_mapping.erase(node->key);
node->data = data;
node->key = key;
_mapping[key] = node;
attach(node);
} else {
node = _freeEntries.back();
_freeEntries.pop_back();
node->key = key;
node->data = data;
_mapping[key] = node;
attach(node);
}
}
}
void AdGroupPool::CheckIfHaveCreative(hash_map<Ice::Long, AdGroupPtr> & group_pool) {
for (hash_map<Ice::Long, AdGroupPtr>::iterator git = group_pool.begin(); git != group_pool.end();) {
if (!git->second->HasCreatives()) {
// MCE_DEBUG("AdGroupPool::Init --> because obj->HasCreatives is false so erase it groupid = " << git->first);
group_pool.erase(git++);
} else{
++git;
}
}
}
/*************************************************
* Function: * check_connect_timeout
* Description: * 检测长时间没反应的网络连接，并关闭删除
* Input: *
* Output: *
* Others: *
*************************************************/
void *check_connect_timeout(void* para)
{
hash_map<int, sockStruct>::iterator it_find;
for(it_find = sock_map.begin(); it_find!=sock_map.end(); ++it_find){
if( time((time_t*)0) - (it_find->second).time > 120){ //时间更改
free((it_find->second).recvBuf);
sock_map.erase(it_find);
close(it_find->first);
}
}
}
void remove (int id){
if(act[id]){
for(unsigned int i=0; i<acttimers.size(); i++){
if(acttimers[i].id == id){
acttimers.erase(acttimers.begin()+i);
return;
}
}
}
else{
for(unsigned int i=0; i<timers.size(); i++){
if(timers[i].id == id){
timers.erase(timers.begin()+i);
return;
}
}
}
if(act.find(id) != act.end())
act.erase(id);
}
void MltRuntime::parse_struct(json_t* v, const JsonPath& curPath,
hash_map<string, JsonPath>& uuid_paths, int erase) throw(Exception)
{
json_t* je = json_object_get(v, "uuid");
if ( je && json_is_string(je) && strlen(json_string_value(je)) ) {
string uuid = json_string_value(je);
if (!erase) {
if ( uuid_paths.find(uuid) != uuid_paths.end()) {
throw_error_v(ErrorRuntimeJsonUUIDDup, "uuid dup:%s", uuid.c_str());
}
uuid_paths[uuid] = curPath;
}
else {
uuid_paths.erase(string(uuid));
}
}
void* it = json_object_iter(v);
while(it) {
const char* k = json_object_iter_key(it);
je = json_object_iter_value(it);
it = json_object_iter_next(v, it);
if ( json_is_object(je) && json_object_size(je) > 0 ) {
JsonPath subPath(curPath);
subPath.push_back(k);
parse_struct(je, subPath, uuid_paths, erase);
}
else if (json_is_array(je) && json_array_size(je) > 0) {
int sz = json_array_size(je);
for ( int i=0; i<sz; i++ ) {
json_t* ae = json_array_get(je, i);
if ( json_is_object(ae) && json_object_size(ae) > 0 ) {
JsonPath subPath(curPath);
subPath.push_back(k, i);
parse_struct(ae, subPath, uuid_paths, erase);
}
}
}
}
}
int preOrder(Node* head, int sum, int preSum, int level, int &maxlen, hash_map<int, int> &sumMap)
{
if (head == NULL)
return maxlen;
int curSum = preSum + head->value;
if (sumMap.count(curSum - sum) == 1)
{
maxlen = (level - sumMap[curSum - sum]) > maxlen ? (level - sumMap[curSum - sum]) : maxlen;
}
if (sumMap.count(curSum) == 0)
{
sumMap.insert(make_pair(curSum, level));
}
maxlen = preOrder(head->left, sum, curSum, level + 1, maxlen, sumMap);
maxlen = preOrder(head->right, sum, curSum, level + 1, maxlen, sumMap);
if (level == sumMap[curSum])
{
sumMap.erase(curSum);
}
return maxlen;
}
/*
handle_message - 处理每个 socket 上的消息收发
*/
int handle_message(int new_fd)
{
char buf[MAXBUF + 1];
char sendbuf[MAXBUF+1];
int len;
/* 开始处理每个新连接上的数据收发 */
bzero(buf, MAXBUF + 1);
/* 接收客户端的消息 */
//len = recv(new_fd, buf, MAXBUF, 0);
int nRecvBuf = MAXRECVBUF; //设置为32K
setsockopt(new_fd, SOL_SOCKET, SO_RCVBUF, ( const char* )&nRecvBuf, sizeof(int));
len=recv(new_fd,&buf, MAXBUF,0);
//--------------------------------------------------------------------------------------------
//这块为了使用ab测试
char bufSend[1000] = {0};
sprintf(bufSend,"HTTP/1.0 200 OK\r\nContent-type: text/plain\r\n\r\n%s","Hello world!\n");
send(new_fd,bufSend,strlen(buf),0);
//--------------------------------------------------------------------------------------------
if (len > 0){
//printf ("%d接收消息成功:'%s'，共%d个字节的数据\n", new_fd, buf, len);
//hash-map
hash_map<int, sockStruct>::iterator it_find;
it_find = sock_map.find(new_fd);
if(it_find == sock_map.end()){
//新的网络连接，申请新的接收缓冲区，并放入map中
//printf("new socket %d\n", new_fd);
sockStruct newSockStruct;
newSockStruct.time = time((time_t*)0);
newSockStruct.recvBuf = (unsigned int*)malloc(1000);
memset(newSockStruct.recvBuf, 0, 1000);
strcat((char*)newSockStruct.recvBuf, buf);
sock_map.insert(pair<int,sockStruct>(new_fd, newSockStruct));
}else{
//网络连接已经存在，找到对应的数据缓冲区，将接收到的数据拼接到数据缓冲区中
//printf("socket %d exist!\n", it_find->first);
(it_find->second).time = time((time_t*)0); //时间更改
char* bufSockMap = (char*)(it_find->second).recvBuf; //数据存储
strcat(bufSockMap, buf);
//printf("bufSockMap:%s\n", bufSockMap);
}
}
else {
if (len < 0)
printf ("消息接收失败！错误代码是%d，错误信息是'%s'\n",
errno, strerror(errno));
else {
//将socket从map中移除
/*
hash_map::iterator it_find;
it_find = sock_map.find(new_fd);
sock_map.erase(it_find);
*/
printf("client %d quit!\n",new_fd);
}
//close(new_fd);
return -1;
}
/* 处理每个新连接上的数据收发结束 */
//关闭socket的时候，要释放接收缓冲区。
hash_map<int, sockStruct>::iterator it_find;
it_find = sock_map.find(new_fd);
free((it_find->second).recvBuf);
sock_map.erase(it_find);
close(new_fd);
return len;
}
void select_remove_form_map( unsigned long socket ){
if( socket <=0 ) return;
select_sockets_hash_map.erase(socket);
}
///////////////////////////////////////////////////////////
//Save & Trace Variables
void UpdateInstructionMap
(
hash_map <op_t,OperandPosition,OpTHashCompareStr> &OperandsHash,
hash_map <int,ea_t> &FlagsHash,
//Instruction Hash and Map
multimap <OperandPosition,OperandPosition,OperandPositionCompareTrait> &InstructionMap,
hash_map <ea_t,insn_t> &InstructionHash,
insn_t &instruction
)
{
ea_t address=instruction.ea;
InstructionHash.insert(pair<ea_t,insn_t>(address,instruction));
char Features[UA_MAXOP*2];
GetFeatureBits(instruction.itype,Features,sizeof(Features));
if(Debug>0)
WriteToLogFile(gLogFile,"%s(%X) %s\r\n",ph.instruc[instruction.itype].name,instruction.itype,GetFeatureStr(ph.instruc[instruction.itype].feature).c_str());
//Flags Tracing
list <int> Flags=GetRelatedFlags(instruction.itype,true);
list <int>::iterator FlagsIter;
for(FlagsIter=Flags.begin();FlagsIter!=Flags.end();FlagsIter++)
{
//Set Flags: FlagsHash
FlagsHash.insert(pair<int,ea_t>(*FlagsIter,address));
}
Flags=GetRelatedFlags(instruction.itype,false);
for(FlagsIter=Flags.begin();FlagsIter!=Flags.end();FlagsIter++)
{
//Use Flags: FlagsHash
hash_map <int,ea_t>::iterator FlagsHashIter=FlagsHash.find(*FlagsIter);
if(FlagsHashIter!=FlagsHash.end())
{
//FlagsHashIter->first
//FlagsHashIter->second
OperandPosition SrcOperandPosition;
SrcOperandPosition.Address=FlagsHashIter->second;
SrcOperandPosition.Index=0;
OperandPosition DstOperandPosition;
DstOperandPosition.Address=address;
DstOperandPosition.Index=0;
InstructionMap.insert(pair<OperandPosition,OperandPosition>(SrcOperandPosition,DstOperandPosition));
}
}
//Return Value Tracing
//Parameter Tracing
//ARM_blx/ARM_blx1/ARM_blx2
if(
(ph.id==PLFM_ARM && (instruction.itype==ARM_bl || instruction.itype==ARM_blx1 || instruction.itype==ARM_blx2)) ||
(ph.id==PLFM_MIPS && (instruction.itype==MIPS_jal || instruction.itype==MIPS_jalx))
)
{
op_t operand;
operand.type=o_reg;
for(int reg=0;reg<5;reg++)
{
operand.reg=reg;
hash_map <op_t,OperandPosition,OpTHashCompareStr>::iterator iter=OperandsHash.find(operand);
if(iter!=OperandsHash.end())
{
OperandPosition SrcOperandPosition;
SrcOperandPosition.Address=iter->second.Address;
SrcOperandPosition.Index=iter->second.Index;
OperandPosition DstOperandPosition;
DstOperandPosition.Address=address;
DstOperandPosition.Index=0;
InstructionMap.insert(pair<OperandPosition,OperandPosition>(SrcOperandPosition,DstOperandPosition));
}else
{
break;
}
}
}
//Operand Tracing
for(int i=UA_MAXOP-1;i>=0;i--)
{
op_t *pOperand=&instruction.Operands[i];
if(pOperand->type>0)
{
//o_mem,o_displ,o_far,o_near -> addr
//o_reg -> reg
//o_phrase,o_displ -> phrase
//outer displacement (o_displ+OF_OUTER_DISP) -> value
//o_imm -> value
WriteToLogFile(gLogFile,"\tOperand %u: [%s%s] ",i,(Features[i]&CF_CHG)?"CHG":"",(Features[i]&CF_USE)?"USE":"");
if(Features[i]&CF_USE)
{
hash_map <op_t,OperandPosition,OpTHashCompareStr>::iterator iter=OperandsHash.find(*pOperand);
if(iter==OperandsHash.end())
{
op_t tmp_op;
memset(&tmp_op,0,sizeof(op_t));
tmp_op.type=o_reg;
if(pOperand->type==o_displ)
{
tmp_op.reg=pOperand->reg;
iter=OperandsHash.find(tmp_op);
if(iter==OperandsHash.end())
{
tmp_op.reg=pOperand->phrase;
iter=OperandsHash.find(tmp_op);
}
}else if(pOperand->type==o_phrase)
{
tmp_op.reg=pOperand->specflag1;
iter=OperandsHash.find(tmp_op);
if(iter==OperandsHash.end())
{
tmp_op.reg=pOperand->phrase;
iter=OperandsHash.find(tmp_op);
}
}
}
if(iter!=OperandsHash.end())
{
OperandPosition SrcOperandPosition;
SrcOperandPosition.Address=iter->second.Address;
SrcOperandPosition.Index=iter->second.Index;
OperandPosition DstOperandPosition;
DstOperandPosition.Address=address;
DstOperandPosition.Index=i;
InstructionMap.insert(pair<OperandPosition,OperandPosition>(SrcOperandPosition,DstOperandPosition));
}
}
if(Features[i]&CF_CHG) //Save to hash(addr,i,op_t)
{
OperandPosition operand_position;
operand_position.Address=address;
operand_position.Index=i;
OperandsHash.erase(instruction.Operands[i]);
WriteToLogFile(gLogFile,"Inserting %u\r\n",i);
OperandsHash.insert(pair<op_t,OperandPosition>(instruction.Operands[i],operand_position));
}
}
}
}
void remove (int id){
if(timers.find(id) != timers.end())
timers.erase(id);
}
unsigned BUDataStructures::calculateGraphs(const Function *F,
std::vector<const Function*> &Stack,
unsigned &NextID,
hash_map<const Function*, unsigned> &ValMap) {
assert(!ValMap.count(F) && "Shouldn't revisit functions!");
unsigned Min = NextID++, MyID = Min;
ValMap[F] = Min;
Stack.push_back(F);
// FIXME! This test should be generalized to be any function that we have
// already processed, in the case when there isn't a main or there are
// unreachable functions!
if (F->isDeclaration()) { // sprintf, fprintf, sscanf, etc...
// No callees!
Stack.pop_back();
ValMap[F] = ~0;
return Min;
}
DSGraph* Graph = getOrFetchDSGraph(F);
// Find all callee functions.
std::vector<const Function*> CalleeFunctions;
GetAllAuxCallees(Graph, CalleeFunctions);
std::sort(CalleeFunctions.begin(), CalleeFunctions.end());
std::vector<const Function*>::iterator uid = std::unique(CalleeFunctions.begin(), CalleeFunctions.end());
CalleeFunctions.resize(uid - CalleeFunctions.begin());
// The edges out of the current node are the call site targets...
for (unsigned i = 0, e = CalleeFunctions.size(); i != e; ++i) {
const Function *Callee = CalleeFunctions[i];
unsigned M;
// Have we visited the destination function yet?
hash_map<const Function*, unsigned>::iterator It = ValMap.find(Callee);
if (It == ValMap.end()) // No, visit it now.
M = calculateGraphs(Callee, Stack, NextID, ValMap);
else // Yes, get it's number.
M = It->second;
if (M < Min) Min = M;
}
assert(ValMap[F] == MyID && "SCC construction assumption wrong!");
if (Min != MyID)
return Min; // This is part of a larger SCC!
// If this is a new SCC, process it now.
if (Stack.back() == F) { // Special case the single "SCC" case here.
DEBUG(errs() << "Visiting single node SCC #: " << MyID << " fn: "
<< F->getName() << "\n");
Stack.pop_back();
DEBUG(errs() << " [BU] Calculating graph for: " << F->getName()<< "\n");
calculateGraph(Graph);
DEBUG(errs() << " [BU] Done inlining: " << F->getName() << " ["
<< Graph->getGraphSize() << "+" << Graph->getAuxFunctionCalls().size()
<< "]\n");
if (MaxSCC < 1) MaxSCC = 1;
// Should we revisit the graph? Only do it if there are now new resolvable
// callees or new callees
GetAllAuxCallees(Graph, CalleeFunctions);
if (CalleeFunctions.size()) {
DEBUG(errs() << "Recalculating " << F->getName() << " due to new knowledge\n");
ValMap.erase(F);
return calculateGraphs(F, Stack, NextID, ValMap);
} else {
ValMap[F] = ~0U;
return MyID;
}
} else {
// SCCFunctions - Keep track of the functions in the current SCC
//
std::vector<DSGraph*> SCCGraphs;
unsigned SCCSize = 1;
const Function *NF = Stack.back();
ValMap[NF] = ~0U;
DSGraph* SCCGraph = getDSGraph(NF);
// First thing first, collapse all of the DSGraphs into a single graph for
// the entire SCC. Splice all of the graphs into one and discard all of the
// old graphs.
//
while (NF != F) {
Stack.pop_back();
NF = Stack.back();
ValMap[NF] = ~0U;
DSGraph* NFG = getDSGraph(NF);
if (NFG != SCCGraph) {
// Update the Function -> DSG map.
for (DSGraph::retnodes_iterator I = NFG->retnodes_begin(),
E = NFG->retnodes_end(); I != E; ++I)
setDSGraph(I->first, SCCGraph);
SCCGraph->spliceFrom(NFG);
delete NFG;
++SCCSize;
}
}
Stack.pop_back();
DEBUG(errs() << "Calculating graph for SCC #: " << MyID << " of size: "
<< SCCSize << "\n");
// Compute the Max SCC Size.
if (MaxSCC < SCCSize)
MaxSCC = SCCSize;
// Clean up the graph before we start inlining a bunch again...
SCCGraph->removeDeadNodes(DSGraph::KeepUnreachableGlobals);
// Now that we have one big happy family, resolve all of the call sites in
// the graph...
calculateGraph(SCCGraph);
DEBUG(errs() << " [BU] Done inlining SCC [" << SCCGraph->getGraphSize()
<< "+" << SCCGraph->getAuxFunctionCalls().size() << "]\n"
<< "DONE with SCC #: " << MyID << "\n");
// We never have to revisit "SCC" processed functions...
return MyID;
}
return MyID; // == Min
}
void _Catalog_locale_map::erase(int key)
{
if (M)
M->erase(key);
}
