/****************************************************************************** * * * BYTE * _Init_Alloc( BYTE *pRamStart, DWORD dwRamSize ) * * * ******************************************************************************* * * This function initializes a buffer for the internal memory allocation pool. * * Where: * pRamStart - beginning address of the linear buffer memory * dwRamTop - size in bytes of the buffer memory * * Returns: * Memory handle to be passed to subsequent mallocHeap() and freeHeap() * functions. That is the "heap". * This is actually the starting address pRamStart. * * NULL - memory could not be initialized (invalid size/address) * ******************************************************************************/ static BYTE * _Init_Alloc( BYTE *pRamStart, DWORD dwRamSize ) { Tmalloc *pMalloc; BYTE * pFree; // Some sanity checking if( dwRamSize < 32 ) return( NULL ); // Set the dummy free structure at the beginning of the free block to // easily traverse the linked list (a sentinel) pMalloc = TM(pRamStart); // Get the buffer start pFree = (char*)pMalloc; // Set the free list beginning pMalloc->size = 0; // No one can request that much! pMalloc->next = STM(pMalloc + 1); // Next structure immediately follows pMalloc = TM(pMalloc->next); // Next free block header pMalloc->size = dwRamSize - HEADER_SIZE; // That's how much is really free pMalloc->next = NULL; // Last block in the list // Return the address of a heap that is now initialized return( pFree ); }
test_report benchmark_test_with_external_configuration(std::string test_casename, const std::string function_name, int flag){ std::cout << "test case: " << test_casename << " starts with external configuration" << std::endl; general_configuration ext_conf_file("configuration_"+function_name+".txt"); Overall_Optimisation_Configuration_Settings myConf2(test_casename, ext_conf_file, "reference_point_"+function_name+".txt", "penalty_point_"+function_name+".txt", "lower_bound_"+function_name+".txt", "upper_bound_"+function_name+".txt", "starting_point_"+function_name+".txt", "current_step_"+function_name+".txt"); const unsigned int n_of_variables=myConf2.getExternalConfigurationFile().getVar(); const unsigned int n_of_objectives=myConf2.getExternalConfigurationFile().getObj(); objective_function_formulae obj_function(n_of_objectives); ObjectiveFunctionBasic<double> TS_ObjFunc(myConf2, obj_function); Container2 MTM(n_of_variables, n_of_objectives, "MTM","./memories"); Container2 IM(n_of_variables, n_of_objectives, "IM","./memories"); Container2 HISTORY(n_of_variables, n_of_objectives, "HISTORY","./memories"); STM_Container2 STM(myConf2.getExternalConfigurationFile().getStmSize(), n_of_variables, "STM", "./memories"); LTM_Container2Basic2<double> LTM( n_of_variables , myConf2.getExternalConfigurationFile().getRegions(), myConf2.get_lower_bound(), myConf2.get_upper_bound(),"LTM", "./memories"); std::cout << "Memories done!" << std::endl; TabuSearch TS(myConf2, flag, TS_ObjFunc, MTM, IM, HISTORY, STM, LTM); double hyper_volume_indicator=TS.search2(); return test_report(myConf2.getCaseName(), TS.getDatumPnt(), hyper_volume_indicator) ; }
void ARMAssembler::epilog(uint32_t touched) { touched &= LSAVED; if (touched) { // write prolog code uint32_t* pc = mPC; mPC = mPrologPC; STM(AL, FD, SP, 1, touched | LLR); mPC = pc; // write epilog code LDM(AL, FD, SP, 1, touched | LLR); BX(AL, LR); } else { // heh, no registers to save! // write prolog code uint32_t* pc = mPC; mPC = mPrologPC; MOV(AL, 0, R0, R0); // NOP mPC = pc; // write epilog code BX(AL, LR); } }
void ARMAssembler::prolog() { // write dummy prolog code mPrologPC = mPC; STM(AL, FD, SP, 1, LSAVED); }
test_report benchmark_test_with_internal_configuration(std::string test_casename, const std::string function_name, int flag, int nVar){ std::ofstream report_file("tests_report_file.txt", std::ios::app); time_t start_time; time (&start_time); std::cout << "test case: " << test_casename << " starts with internal configuration" << std::endl; general_configuration internal_configuration_old("no_filename", 10, //1 - diversify 5, //2 - intensify 15, //3 - reduce 0.00, //4 - SS 0.5, //5 - SSRF 1, //6 - save step 3, //7 - sampling nVar, //8 - nVar 2, //9 - nObj 0, //10 loop limit 3000, //11 evaluations limit 0, //12 Improvements limit , number of consecutive improvements 4, //13 - number of regions 6, //14 - STM size "HV", // 15 "full", //16 -0.05, //17 - starting point 200, //18 300); //19 general_configuration internal_configuration("configuration.txt"); ObjFunction2 test_reference_point=ObjFunction2(2, 22.0); ObjFunction2 test_penalty_point=ObjFunction2(2,33333.0); Point2 test_lower_bound=Point2(nVar,0.0); test_lower_bound[0]=5.0; test_lower_bound[1]=1.0; test_lower_bound[2]=11.0; Point2 test_upper_bound=Point2(nVar,1.0); test_upper_bound[0]=11.0; test_upper_bound[1]=200.0; test_upper_bound[2]=29.0; Point2 test_starting_point=Point2(nVar,0.5); test_starting_point[0]=7.0; test_starting_point[1]=100.0; test_starting_point[2]=24.5; Point2 test_current_step=Point2(nVar,0.05); test_current_step[0]=0.1666666; test_current_step[1]=0.050251256; test_current_step[2]=0.055555556; Overall_Optimisation_Configuration_Settings myConf2(test_casename, internal_configuration, test_reference_point, test_penalty_point, test_lower_bound, test_upper_bound, test_starting_point, test_current_step); const unsigned int n_of_variables=myConf2.getExternalConfigurationFile().getVar(); const unsigned int n_of_objectives=myConf2.getExternalConfigurationFile().getObj(); objective_function_formulae obj_function(n_of_objectives); ObjectiveFunctionBasic<double> TS_ObjFunc(myConf2, obj_function); Container2 MTM(n_of_variables, n_of_objectives, "MTM","./memories"); Container2 IM(n_of_variables, n_of_objectives, "IM","./memories"); Container2 HISTORY(n_of_variables, n_of_objectives, "HISTORY","./memories"); STM_Container2 STM(myConf2.getExternalConfigurationFile().getStmSize(), n_of_variables, "STM", "./memories"); LTM_Container2Basic2<double> LTM( n_of_variables , myConf2.getExternalConfigurationFile().getRegions(), myConf2.get_lower_bound(), myConf2.get_upper_bound(),"LTM", "./memories"); std::cout << "Memories done!" << std::endl; TabuSearch TS(myConf2, flag, TS_ObjFunc, MTM, IM, HISTORY, STM, LTM); double hyper_volume_indicator=TS.search2(); time_t end; time (&end); double dif = difftime (end,start_time); std::cout << "end in " << dif<< "seconds" << std::endl; report_file << test_casename << "\t" << n_of_variables << "\t" << dif << " seconds " << __DATE__ << "\t" << __TIME__ << std::endl; report_file.close(); return test_report(myConf2.getCaseName(), TS.getDatumPnt(), hyper_volume_indicator) ; }
/****************************************************************************** * * * void freeHeap(BYTE *pHeap, void *mPtr ) * * * ******************************************************************************* * * Frees the memory that was allocated using mallocHeap() from the internal * memory allocation pool (heap). * * The pointer mPtr can be NULL. * * Where: * pHeap is the requested heap * pMem - pointer to a memory block to be freed * ******************************************************************************/ void freeHeap(BYTE *pHeap, void *mPtr ) { Tmalloc *pLast; Tmalloc *pMem; Tmalloc *pMalloc; // Return if pointer is NULL (should not happen) if( mPtr==NULL ) return; // Get the allocation structure pMalloc = (Tmalloc*)((int)mPtr - HEADER_SIZE); // Check for the magic number to ensure that the right block was passed if( (int)pMalloc->next != MALLOC_COOKIE ) { // Should print some error message in the future //printf(" *** ERROR - Magic Number Wrong: %08X ***\n",(int)pMalloc->next ); return; } // Now we have to return the block to the list of free blocks, so find the // place in the list to insert it. The free list is ordered by the address // of the blocks that it holds pLast = TM(pHeap); pMem = TM(pLast->next); // Traverse the free list and find where the new block should be inserted while( (pMem != NULL) && (pMem < pMalloc) ) { pLast = pMem; pMem = TM(pMem->next); } // If pMem is NULL, the block to be freed lies after the last node in the // free list, so link it at the end. if( pMem == NULL ) { pLast->next = STM(pMalloc); // Last node in the free list pMalloc->next = NULL; // Terminate it // The new, last free block may be merged with the preceeding one if( (int)pLast + pLast->size == (int)pMalloc ) { pLast->size += pMalloc->size; pLast->next = NULL; } return; } // Now pLast points to the last node before pMalloc, and pMem points to // the next node. They just have to be linked now. pLast->next = STM(pMalloc); pMalloc->next = STM(pMem); // If pMem node is immediately after pMalloc, they will be merged. if( (int)pMalloc + pMalloc->size == (int)pMem ) { // Merge new node and the successor pointed by pMem pMalloc->size += pMem->size; pMalloc->next = pMem->next; } // If the newly freed node is after another free node, merge them if( (int)pLast + pLast->size == (int)pMalloc ) { pLast->size += pMalloc->size; pLast->next = pMalloc->next; } return; }
/****************************************************************************** * * * char *mallocHeap(BYTE *pHeap, UINT size) * * * ******************************************************************************* * * Allocates a block of memory within the Linice internal heap. * * Where: * pHeap is the requested heap * size is the requested size of the memory block * * Returns: * Pointer to newly allocated block * NULL - memory could not be allocated * ******************************************************************************/ char *mallocHeap(BYTE *pHeap, UINT size) { Tmalloc *pLast; Tmalloc *pNew; // This should really be some sort of assert... if( pHeap == NULL ) return(NULL); // If the requested size is 0, do nothing. if( (size == 0) ) return NULL; // Set the size to be a multiple of 4 to keep the allignemnt // Also, add the size of the header to be allocated size = ((size+3) & 0xFFFFFFFC) + HEADER_SIZE; // Debug allocations: //dprinth(1, "malloc(%d)", size); // Traverse the free list and find the first block large enough for the // block of the requested size pLast = TM(pHeap); pNew = TM(pLast->next); // This effectively implements the first-fit memory allocation strategy while( (pNew != NULL) && (pNew->size < size )) { pLast = pNew; pNew = TM(pNew->next); } // Check if we could not find the block large enough and are at the end of // the list if( pNew==NULL ) return( NULL ); // A free memory block that was found is large enough for the request, but // maybe too large, so we may want to split it: // Two things can happen now: either we will link another free block // at the end of the allocated one, or not. Linking another block will // increase fragmentation so we will do it only if the space that remains // is larger or equal to 16 bytes (arbitrary value) if( pNew->size >= size+16+HEADER_SIZE ) { // Link in another free block pLast->next = (struct Tmalloc*)((int)pNew + size); pLast = TM(pLast->next); // Point to the new free block pLast->next = pNew->next; // Link in the next free block pLast->size = pNew->size - size; pNew->size = size; // Set the allocated block size pNew->next = STM(MALLOC_COOKIE); // And the debug cookie return (void*)((int)pNew + HEADER_SIZE); } else { // There was not enough free space to link in new free node, so just // allocate the whole block. pLast->next = pNew->next; // Skip the newly found space // pNew->size is all the size of a block. No need to change. pNew->next = STM(MALLOC_COOKIE); // Set the debug cookie return (void*)((int)pNew + HEADER_SIZE); } }