bool FDefaultValueHelper::IsStringValidInteger(const TCHAR* Start, const TCHAR* End, int32& OutBase)
{
bool bAllowHex = false;
bool bADigitFound = false;
if( !Trim(Start, End) )
{
return false;
}
if( ( TS(TEXT("-")) == *Start ) || ( TS(TEXT("+")) == *Start ) )
{
Start++;
}
if( !Trim(Start, End) )
{
return false;
}
if( TS(TEXT("0")) == *Start )
{
Start++;
bADigitFound = true;
if( ( TS(TEXT("x")) == *Start ) || ( TS(TEXT("X")) == *Start ) )
{
Start++;
bAllowHex = true;
bADigitFound = false;
OutBase = 16;
}
else
{
OutBase = 8;
}
}
else
{
OutBase = 10;
}
if( bAllowHex )
{
for(; ( Start < End ) && FChar::IsHexDigit( *Start ); ++Start)
{
bADigitFound = true;
}
}
else
{
for(; ( Start < End ) && FChar::IsDigit( *Start ); ++Start)
{
bADigitFound = true;
}
}
return ( !Trim(Start, End) ) && bADigitFound;
}
void *
lz_timer_proc (void *ctx)
{
lz_timer_registry_t *reg = NULL;
if (ctx == NULL)
{
lz_log ("timer", LZ_LOG_ERROR, "invalid argument");
return NULL;
}
reg = ctx;
while (!reg->fin) {
unsigned long long now;
struct timeval now_tv;
lz_timer_t *event = NULL;
gettimeofday (&now_tv, NULL);
now = TS (now_tv);
while (1) {
unsigned long long at;
char need_cbk = 0;
pthread_mutex_lock (®->lock);
{
event = reg->active.next;
at = TS (event->at);
if (event != ®->active && now >= at) {
need_cbk = 1;
lz_timer_call_stale (reg, event);
}
}
pthread_mutex_unlock (®->lock);
if (need_cbk)
event->cbk (event->data);
else
break;
}
usleep (1000000);
}
pthread_mutex_lock (®->lock);
{
while (reg->active.next != ®->active) {
lz_timer_call_cancel (ctx, reg->active.next);
}
while (reg->stale.next != ®->stale) {
lz_timer_call_cancel (ctx, reg->stale.next);
}
}
pthread_mutex_unlock (®->lock);
pthread_mutex_destroy (®->lock);
return NULL;
}
gf_timer_t *
gf_timer_call_after (glusterfs_ctx_t *ctx,
struct timespec delta,
gf_timer_cbk_t callbk,
void *data)
{
gf_timer_registry_t *reg = NULL;
gf_timer_t *event = NULL;
gf_timer_t *trav = NULL;
uint64_t at = 0;
if (ctx == NULL)
{
gf_msg_callingfn ("timer", GF_LOG_ERROR, EINVAL,
LG_MSG_INVALID_ARG, "invalid argument");
return NULL;
}
reg = gf_timer_registry_init (ctx);
if (!reg) {
gf_msg_callingfn ("timer", GF_LOG_ERROR, 0,
LG_MSG_TIMER_REGISTER_ERROR, "!reg");
return NULL;
}
event = GF_CALLOC (1, sizeof (*event), gf_common_mt_gf_timer_t);
if (!event) {
return NULL;
}
timespec_now (&event->at);
timespec_adjust_delta (&event->at, delta);
at = TS (event->at);
event->callbk = callbk;
event->data = data;
event->xl = THIS;
LOCK (®->lock);
{
trav = reg->active.prev;
while (trav != ®->active) {
if (TS (trav->at) < at)
break;
trav = trav->prev;
}
event->prev = trav;
event->next = event->prev->next;
event->prev->next = event;
event->next->prev = event;
}
UNLOCK (®->lock);
return event;
}
gf_timer_t *
gf_timer_call_after (glusterfs_ctx_t *ctx,
struct timeval delta,
gf_timer_cbk_t callbk,
void *data)
{
gf_timer_registry_t *reg = NULL;
gf_timer_t *event = NULL;
gf_timer_t *trav = NULL;
unsigned long long at = 0L;
if (ctx == NULL)
{
gf_log_callingfn ("timer", GF_LOG_ERROR, "invalid argument");
return NULL;
}
reg = gf_timer_registry_init (ctx);
if (!reg) {
gf_log_callingfn ("timer", GF_LOG_ERROR, "!reg");
return NULL;
}
event = GF_CALLOC (1, sizeof (*event), gf_common_mt_gf_timer_t);
if (!event) {
return NULL;
}
gettimeofday (&event->at, NULL);
event->at.tv_usec = ((event->at.tv_usec + delta.tv_usec) % 1000000);
event->at.tv_sec += ((event->at.tv_usec + delta.tv_usec) / 1000000);
event->at.tv_sec += delta.tv_sec;
at = TS (event->at);
event->callbk = callbk;
event->data = data;
event->xl = THIS;
pthread_mutex_lock (®->lock);
{
trav = reg->active.prev;
while (trav != ®->active) {
if (TS (trav->at) < at)
break;
trav = trav->prev;
}
event->prev = trav;
event->next = event->prev->next;
event->prev->next = event;
event->next->prev = event;
}
pthread_mutex_unlock (®->lock);
return event;
}
bool FDefaultValueHelper::GetParameters(const FString& Source, const FString& TypeName, FString& OutForm)
{
int32 Pos = 0;
if( !Trim(Pos, Source) )
{
return false;
}
// find the beginning of actual val after "TypeName ( "
if( Source.Find(TypeName, ESearchCase::CaseSensitive) != Pos )
{
return false;
}
Pos += TypeName.Len();
if( !Trim(Pos, Source) )
{
return false;
}
if( TS(TEXT("(")) != Source[Pos++] )
{
return false;
}
if( !Trim(Pos, Source) )
{
return false;
}
const int32 StartPos = Pos;
int32 EndPos = -1, PendingParentheses = 1;
// find the end of the actual string before " ) "
for(Pos = Source.Len() - 1; Pos > StartPos; --Pos )
{
if( TS(TEXT(")")) == Source[Pos])
{
PendingParentheses--;
}
else if(!IsWhitespace(Source[Pos]))
{
EndPos = Pos+1;
break;
}
}
if(EndPos < 0 || 0 != PendingParentheses)
{
return false;
}
OutForm = Source.Mid(StartPos, EndPos - StartPos);
return true;
}
// 插入一个事件到定时器链表中
gf_timer_t *
gf_timer_call_after (glusterfs_ctx_t *ctx,
struct timespec delta,
gf_timer_cbk_t callbk,
void *data)
{
gf_timer_registry_t *reg = NULL;
gf_timer_t *event = NULL;
gf_timer_t *trav = NULL;
uint64_t at = 0;
if (ctx == NULL)
{
gf_log_callingfn ("timer", GF_LOG_ERROR, "invalid argument");
return NULL;
}
reg = gf_timer_registry_init (ctx);
if (!reg) {
gf_log_callingfn ("timer", GF_LOG_ERROR, "!reg");
return NULL;
}
event = GF_CALLOC (1, sizeof (*event), gf_common_mt_gf_timer_t);
if (!event) {
return NULL;
}
timespec_now (&event->at);
timespec_adjust_delta (&event->at, delta);
at = TS (event->at);
event->callbk = callbk;
event->data = data;
event->xl = THIS;
pthread_mutex_lock (®->lock);
{
//列表最后一个
trav = reg->active.prev;
//找最后一个时间比我早的(链表是按时间排序的)
while (trav != ®->active) {
if (TS (trav->at) < at)
break;
trav = trav->prev;
}
event->prev = trav;
event->next = event->prev->next;
event->prev->next = event;
event->next->prev = event;
}
pthread_mutex_unlock (®->lock);
return event;
}
gf_timer_t *
gf_timer_call_after (glusterfs_ctx_t *ctx,
struct timeval delta,
gf_timer_cbk_t cbk,
void *data)
{
if (!ctx) {
gf_log ("timer", GF_LOG_ERROR, "!ctx");
return NULL;
}
gf_timer_registry_t *reg = gf_timer_registry_init (ctx);
gf_timer_t *event, *trav;
unsigned long long at;
if (!reg) {
gf_log ("timer", GF_LOG_ERROR, "!reg");
return NULL;
}
event = calloc (1, sizeof (*event));
if (!event) {
gf_log ("timer", GF_LOG_CRITICAL, "Not enough memory");
return NULL;
}
gettimeofday (&event->at, NULL);
event->at.tv_usec = ((event->at.tv_usec + delta.tv_usec) % 1000000);
event->at.tv_sec += ((event->at.tv_usec + delta.tv_usec) / 1000000);
event->at.tv_sec += delta.tv_sec;
at = TS (event->at);
event->cbk = cbk;
event->data = data;
pthread_mutex_lock (®->lock);
{
trav = reg->active.prev;
while (trav != ®->active) {
if (TS (trav->at) < at)
break;
trav = trav->prev;
}
event->prev = trav;
event->next = event->prev->next;
event->prev->next = event;
event->next->prev = event;
}
pthread_mutex_unlock (®->lock);
return event;
}
COObject *
COObject_get(COObject *name)
{
COObject *co;
co = CODict_GetItem(TS(frame)->f_globals, name);
if (co) {
return co;
}
// at last
co = CODict_GetItem(TS(frame)->f_builtins, name);
if (co) {
return co;
}
return NULL;
}
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) ;
}
static int etnaviv_ioctl_gem_wait(struct drm_device *dev, void *data,
struct drm_file *file)
{
struct etnaviv_drm_private *priv = dev->dev_private;
struct drm_etnaviv_gem_wait *args = data;
struct timespec *timeout = &TS(args->timeout);
struct drm_gem_object *obj;
struct etnaviv_gpu *gpu;
int ret;
if (args->flags & ~(ETNA_WAIT_NONBLOCK))
return -EINVAL;
if (args->pipe >= ETNA_MAX_PIPES)
return -EINVAL;
gpu = priv->gpu[args->pipe];
if (!gpu)
return -ENXIO;
obj = drm_gem_object_lookup(dev, file, args->handle);
if (!obj)
return -ENOENT;
if (args->flags & ETNA_WAIT_NONBLOCK)
timeout = NULL;
ret = etnaviv_gem_wait_bo(gpu, obj, timeout);
drm_gem_object_unreference_unlocked(obj);
return ret;
}
/* Function: mdlInitializeSampleTimes =========================================
* Abstract:
* S-function is comprised of only continuous sample time elements
*/
static void mdlInitializeSampleTimes(SimStruct *S)
{
/* fixed sample time passed from options */
ssSetSampleTime(S, 0, TS(S));
ssSetOffsetTime(S, 0, 0.0);
ssSetModelReferenceSampleTimeDefaultInheritance(S);
}
lz_timer_t *
lz_timer_call_after (lz_timer_registry_t *timer, struct timeval delta,
lz_timer_cbk_t cbk, void *data)
{
lz_timer_registry_t *reg = NULL;
lz_timer_t *event = NULL;
lz_timer_t *trav = NULL;
unsigned long long at = 0L;
if (timer == NULL)
{
lz_log ("timer", LZ_LOG_ERROR, "invalid argument");
return NULL;
}
reg = timer;
event = CALLOC (1, sizeof (*event));
if (!event) {
lz_log ("timer", LZ_LOG_CRITICAL, "Not enough memory");
return NULL;
}
gettimeofday (&event->at, NULL);
event->at.tv_usec = ((event->at.tv_usec + delta.tv_usec) % 1000000);
event->at.tv_sec += ((event->at.tv_usec + delta.tv_usec) / 1000000);
event->at.tv_sec += delta.tv_sec;
at = TS (event->at);
event->cbk = cbk;
event->data = data;
pthread_mutex_lock (®->lock);
{
trav = reg->active.prev;
while (trav != ®->active) {
if (TS (trav->at) < at)
break;
trav = trav->prev;
}
event->prev = trav;
event->next = event->prev->next;
event->prev->next = event;
event->next->prev = event;
}
pthread_mutex_unlock (®->lock);
return event;
}
void *
gf_timer_proc (void *ctx)
{
if (!ctx) {
gf_log ("timer", GF_LOG_ERROR, "(!ctx)");
return 0;
}
gf_timer_registry_t *reg = gf_timer_registry_init (ctx);
if (!reg) {
gf_log ("timer", GF_LOG_ERROR, "!reg");
return NULL;
}
while (!reg->fin) {
unsigned long long now;
struct timeval now_tv;
gf_timer_t *event;
gettimeofday (&now_tv, NULL);
now = TS (now_tv);
while (1) {
unsigned long long at;
char need_cbk = 0;
pthread_mutex_lock (®->lock);
{
event = reg->active.next;
at = TS (event->at);
if (event != ®->active && now >= at) {
need_cbk = 1;
gf_timer_call_stale (reg, event);
}
}
pthread_mutex_unlock (®->lock);
if (need_cbk)
event->cbk (event->data);
else
break;
}
usleep (100000);
}
return NULL;
}
void G2_TraceModels(CGhoul2Info_v &ghoul2, vec3_t rayStart, vec3_t rayEnd, CCollisionRecord *collRecMap, int entNum, EG2_Collision eG2TraceType, int useLod, float fRadius)
{
int i, lod;
skin_t *skin;
shader_t *cust_shader;
// walk each possible model for this entity and try tracing against it
for (i=0; i<ghoul2.size(); i++)
{
// don't bother with models that we don't care about.
if (!ghoul2[i].mValid)
{
continue;
}
assert(G2_MODEL_OK(&ghoul2[i]));
// do we really want to collide with this object?
if (ghoul2[i].mFlags & GHOUL2_NOCOLLIDE)
{
continue;
}
if (ghoul2[i].mCustomShader)
{
cust_shader = R_GetShaderByHandle(ghoul2[i].mCustomShader );
}
else
{
cust_shader = NULL;
}
// figure out the custom skin thing
if ( ghoul2[i].mSkin > 0 && ghoul2[i].mSkin < tr.numSkins )
{
skin = R_GetSkinByHandle( ghoul2[i].mSkin );
}
else
{
skin = NULL;
}
lod = G2_DecideTraceLod(ghoul2[i],useLod);
//reset the quick surface override lookup
G2_FindOverrideSurface(-1, ghoul2[i].mSlist);
CTraceSurface TS(ghoul2[i].mSurfaceRoot, ghoul2[i].mSlist, ghoul2[i].currentModel, lod, rayStart, rayEnd, collRecMap, entNum, i, skin, cust_shader, ghoul2[i].mTransformedVertsArray, eG2TraceType, fRadius);
// start the surface recursion loop
G2_TraceSurfaces(TS);
// if we've hit one surface on one model, don't bother doing the rest
if (TS.hitOne)
{
break;
}
}
}
/* Function: mdlInitializeSampleTimes =========================================
* Abstract:
* Specify the sample time
*/
static void mdlInitializeSampleTimes(SimStruct *S)
{
const double Ts = mxGetScalar(TS(S));
ssSetSampleTime(S, 0, Ts);
ssSetOffsetTime(S, 0, 0.0);
/* todo: Is this required?
ssSetModelReferenceSampleTimeDefaultInheritance(S);
*/
}
void TS(graph *g,int i,int visited[])
{
visited[i]=1;
for(int j=0;j<g->v;j++)
{
if(!visited[j] && g->adj[i][j]==1)
TS(g,j,visited);
}
push(i);
}
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
GLOBAL ISM32
validate_TSS
IFN3(
IU16, selector, /* (I) selector to be checked */
IU32 *, descr_addr, /* (O) address of related descriptor */
BOOL, is_switch /* (I) if true we are in task switch */
)
{
BOOL is_ok = TRUE;
IU8 AR;
ISM32 super;
/* must be in GDT */
if ( selector_outside_GDT(selector, descr_addr) )
{
is_ok = FALSE;
}
else
{
/* is it really an available TSS segment (is_switch false) or
is it really a busy TSS segment (is_switch true) */
AR = spr_read_byte((*descr_addr)+5);
super = descriptor_super_type((IU16)AR);
if ( ( !is_switch &&
(super == AVAILABLE_TSS || super == XTND_AVAILABLE_TSS) )
||
( is_switch &&
(super == BUSY_TSS || super == XTND_BUSY_TSS) ) )
; /* ok */
else
is_ok = FALSE;
}
/* handle invalid TSS */
if ( !is_ok )
{
if ( is_switch )
TS(selector, FAULT_VALTSS_SELECTOR);
else
GP(selector, FAULT_VALTSS_SELECTOR);
}
/* must be present */
if ( GET_AR_P(AR) == NOT_PRESENT )
NP(selector, FAULT_VALTSS_NP);
return super;
}
void skeletonize(const cv::Mat &input, cv::Mat &output, bool save_images)
{
TS(total);
TS(imwrite_0);
if (save_images) cv::imwrite("0-input.png", input);
TE(imwrite_0);
// Convert to grayscale my
cv::Mat gray_image_my;
ConvertColor_BGR2GRAY_BT709_fpt(input, gray_image_my);
if (save_images) cv::imwrite("1-convertcolor_my.png", gray_image_my);
// Convert to grayscale my
cv::Mat gray_image;
ConvertColor_BGR2GRAY_BT709(input, gray_image);
if (save_images) cv::imwrite("1-convertcolor.png", gray_image);
// Downscale input image
cv::Mat small_image;
cv::Size small_size(input.cols / 1.5, input.rows / 1.5);
ImageResize(gray_image, small_image, small_size);
if (save_images) cv::imwrite("2-resize.png", small_image);
// Binarization and inversion
cv::threshold(small_image, small_image, 128, 255, cv::THRESH_BINARY_INV);
if (save_images) cv::imwrite("3-threshold.png", small_image);
// Thinning
cv::Mat thinned_image;
GuoHallThinning(small_image, thinned_image);
if (save_images) cv::imwrite("4-thinning.png", thinned_image);
// Back inversion
output = 255 - thinned_image;
if (save_images) cv::imwrite("5-output.png", output);
TE(total);
}
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
GLOBAL VOID
validate_SS_on_stack_change
IFN4(
IU32, priv, /* (I) privilege level to check against */
IU16, selector, /* (I) selector to be checked */
IU32 *, descr, /* (O) address of related descriptor */
CPU_DESCR *, entry /* (O) the decoded descriptor */
)
{
if ( selector_outside_GDT_LDT(selector, descr) )
TS(selector, FAULT_VALSS_CHG_SELECTOR);
read_descriptor_linear(*descr, entry);
/* do access check */
if ( GET_SELECTOR_RPL(selector) != priv ||
GET_AR_DPL(entry->AR) != priv )
TS(selector, FAULT_VALSS_CHG_ACCESS);
/* do type check */
switch ( descriptor_super_type(entry->AR) )
{
case EXPANDUP_WRITEABLE_DATA:
case EXPANDDOWN_WRITEABLE_DATA:
break; /* ok */
default:
TS(selector, FAULT_VALSS_CHG_BAD_SEG_TYPE); /* wrong type */
}
/* finally check it is present */
if ( GET_AR_P(entry->AR) == NOT_PRESENT )
SF(selector, FAULT_VALSS_CHG_NOTPRESENT);
}
int main(int argc, char* argv[]){
if(argc!=5){
usage();
}
omp_set_dynamic(0);
/* Parse Arguments */
omp_thread_count = atoi(argv[1]);
if(omp_thread_count > 50 || omp_thread_count <=1)
usage();
num_barriers = atoi(argv[2]);
if(num_barriers > 1000 || num_barriers <1)
usage();
use_busy_wait = atoi(argv[3]);
if(use_busy_wait!=0 && use_busy_wait!=1)
usage();
busy_wait_count = atoi(argv[4]);
/* Run the experiment */
struct timeval start,end;
omp_set_num_threads(omp_thread_count);
gettimeofday(&start, NULL);
#pragma omp parallel
{
int i;
for(i=0;i<num_barriers;i++){
#pragma omp critical
test++;
barrier();
}
#pragma omp master
fprintf(stderr,"%3d\t",test);
}
gettimeofday(&end, NULL);
fprintf(stderr,"%10.4f\tusec\n",(TS(end)-TS(start))/(double)num_barriers);
}
bool FDefaultValueHelper::IsStringValidFloat(const TCHAR* Start, const TCHAR* End)
{
if( !Trim(Start, End) )
{
return false;
}
if( ( TS(TEXT("-")) == *Start ) || ( TS(TEXT("+")) == *Start ) )
{
Start++;
}
if( !Trim(Start, End) )
{
return false;
}
for(; ( Start < End ) && FChar::IsDigit( *Start ); ++Start ) { }
if( TS(TEXT(".")) == *Start )
{
Start++;
}
for(; ( Start < End ) && FChar::IsDigit( *Start ); ++Start ) { }
if( ( TS(TEXT("e")) == *Start ) || ( TS(TEXT("E")) == *Start ) )
{
Start++;
if( ( TS(TEXT("-")) == *Start ) || ( TS(TEXT("+")) == *Start ) )
{
Start++;
}
}
for(; ( Start < End ) && FChar::IsDigit( *Start ); ++Start) { }
if( ( TS(TEXT("f")) == *Start ) || ( TS(TEXT("F")) == *Start ) )
{
Start++;
}
return !Trim(Start, End);
}
void
COErr_Fetch(COObject **type, COObject **value, COObject **traceback)
{
*type = TS(curexc_type);
*value = TS(curexc_value);
*traceback = TS(curexc_traceback);
TS(curexc_type) = NULL;
TS(curexc_value) = NULL;
TS(curexc_traceback) = NULL;
}
void topologicalsort(graph *g)
{
//initialization of stack
top=NULL;
int visited[g->v];
for(int i=0;i<g->v;i++)
visited[i]=0;
for(int i=0;i<g->v;i++)
{
if(!visited[i])
TS(g,i,visited);
}
while(top!=NULL)
{
int z=pop();
printf("%d->",z);
}
}
static int etnaviv_ioctl_gem_cpu_prep(struct drm_device *dev, void *data,
struct drm_file *file)
{
struct drm_etnaviv_gem_cpu_prep *args = data;
struct drm_gem_object *obj;
int ret;
if (args->op & ~(ETNA_PREP_READ | ETNA_PREP_WRITE | ETNA_PREP_NOSYNC))
return -EINVAL;
obj = drm_gem_object_lookup(dev, file, args->handle);
if (!obj)
return -ENOENT;
ret = etnaviv_gem_cpu_prep(obj, args->op, &TS(args->timeout));
drm_gem_object_unreference_unlocked(obj);
return ret;
}
int OCCFace::loft(std::vector<OCCBase *> profiles, bool ruled, double tolerance)
{
try {
Standard_Boolean isSolid = Standard_False;
Standard_Boolean isRuled = Standard_True;
if (!ruled) isRuled = Standard_False;
BRepOffsetAPI_ThruSections TS(isSolid, isRuled, tolerance);
for (unsigned i=0; i<profiles.size(); i++) {
if (profiles[i]->getShape().ShapeType() == TopAbs_WIRE) {
TS.AddWire(TopoDS::Wire(profiles[i]->getShape()));
} else {
TS.AddVertex(TopoDS::Vertex(profiles[i]->getShape()));
}
}
//TS.CheckCompatibility(Standard_False);
TS.Build();
if (!TS.IsDone()) {
StdFail_NotDone::Raise("Failed in loft operation");;
}
this->setShape(TS.Shape());
// possible fix shape
if (!this->fixShape())
StdFail_NotDone::Raise("Shapes not valid");
} catch(Standard_Failure &err) {
Handle_Standard_Failure e = Standard_Failure::Caught();
const Standard_CString msg = e->GetMessageString();
if (msg != NULL && strlen(msg) > 1) {
setErrorMessage(msg);
} else {
setErrorMessage("Failed to loft");
}
return 0;
}
return 1;
}
static int etnaviv_ioctl_wait_fence(struct drm_device *dev, void *data,
struct drm_file *file)
{
struct drm_etnaviv_wait_fence *args = data;
struct etnaviv_drm_private *priv = dev->dev_private;
struct timespec *timeout = &TS(args->timeout);
struct etnaviv_gpu *gpu;
if (args->flags & ~(ETNA_WAIT_NONBLOCK))
return -EINVAL;
if (args->pipe >= ETNA_MAX_PIPES)
return -EINVAL;
gpu = priv->gpu[args->pipe];
if (!gpu)
return -ENXIO;
if (args->flags & ETNA_WAIT_NONBLOCK)
timeout = NULL;
return etnaviv_gpu_wait_fence_interruptible(gpu, args->fence,
timeout);
}
void
COErr_Restore(COObject *type, COObject *value, COObject *traceback)
{
COObject *oldtype, *oldvalue, *oldtraceback;
oldtype = TS(curexc_type);
oldvalue = TS(curexc_value);
oldtraceback = TS(curexc_traceback);
TS(curexc_type) = type;
TS(curexc_value) = value;
TS(curexc_traceback) = traceback;
CO_XINCREF(type);
CO_XINCREF(value);
CO_XINCREF(traceback);
CO_XDECREF(oldtype);
CO_XDECREF(oldvalue);
CO_XDECREF(oldtraceback);
}
void Rescale(
const char *type, size_t kl, size_t ku,
const TS &cfrom, const TS &cto,
size_t m, size_t n, T* a, size_t lda
) {
if(n == 0 || m == 0) {
return;
}
const TS smlnum = Traits<TS>::min();
const TS bignum = TS(1) / smlnum;
TS cfromc = cfrom;
TS ctoc = cto;
bool done = true;
do {
const TS cfrom1 = cfromc * smlnum;
TS mul;
if(cfrom1 == cfromc) {
// CFROMC is an inf. Multiply by a correctly signed zero for
// finite CTOC, or a NaN if CTOC is infinite.
mul = ctoc / cfromc;
done = true;
//cto1 = ctoc;
} else {
const TS cto1 = ctoc / bignum;
if(cto1 == ctoc) {
// CTOC is either 0 or an inf. In both cases, CTOC itself
// serves as the correct multiplication factor.
mul = ctoc;
done = true;
cfromc = TS(1);
} else if(Traits<TS>::abs(cfrom1) > Traits<TS>::abs(ctoc) && ctoc != TS(0)) {
mul = smlnum;
done = false;
cfromc = cfrom1;
} else if(Traits<TS>::abs(cto1) > Traits<TS>::abs(cfromc)) {
mul = bignum;
done = false;
ctoc = cto1;
} else {
mul = ctoc / cfromc;
done = true;
}
}
switch(type[0]) {
case 'G': // Full matrix
for(size_t j = 0; j < n; ++j) {
for(size_t i = 0; i < m; ++i) {
a[i+j*lda] *= mul;
}
}
break;
case 'L': // Lower triangular matrix
for(size_t j = 0; j < n; ++j) {
for(size_t i = j; i < m; ++i) {
a[i+j*lda] *= mul;
}
}
break;
case 'U': // Upper triangular matrix
for(size_t j = 0; j < n; ++j) {
size_t ilimit = j+1;
if(m < ilimit) {
ilimit = m;
}
for(size_t i = 0; i < ilimit; ++i) {
a[i+j*lda] *= mul;
}
}
break;
case 'H': // Upper Hessenberg matrix
for(size_t j = 0; j < n; ++j) {
size_t ilimit = j+2;
if(m < ilimit) {
ilimit = m;
};
for(size_t i = 0; i < ilimit; ++i) {
a[i+j*lda] *= mul;
}
}
break;
case 'B': // Lower half of a symmetric band matrix
for(size_t j = 0; j < n; ++j) {
size_t ilimit = n-j;
if(kl+1 < ilimit) {
ilimit = kl+1;
}
for(size_t i = 0; i < ilimit; ++i) {
a[i+j*lda] *= mul;
}
}
break;
case 'Q': // Upper half of a symmetric band matrix
for(size_t j = 0; j < n; ++j) {
size_t istart = (ku > j) ? ku-j : 0;
for(size_t i = istart; i <= ku; ++i) {
a[i+j*lda] *= mul;
}
}
case 'Z': // Band matrix
{ size_t k3 = 2*kl + ku + 1;
for(size_t j = 0; j < n; ++j) {
size_t istart = kl+ku-j;
if(kl > istart) {
istart = kl;
}
size_t ilimit = kl + ku + m-j;
if(k3 < ilimit) {
ilimit = k3;
}
for(size_t i = istart; i < ilimit; ++i) {
a[i+j*lda] *= mul;
}
}
}
break;
default:
break;
}
} while(!done);
}
#define TS(_x,_y) TCPOPT_TSTAMP, 10, D(_x), D(_y)
/* There are virtually no OSes that do not send MSS. Support for RFC 1323
and 2018 is not given, so we have to test various combinations here. */
static u8 opt_combos[8][24] = {
{ MSS(SPECIAL_MSS), NOP, EOL }, /* 6 */
{ MSS(SPECIAL_MSS), SOK, NOP, EOL }, /* 8 */
{ MSS(SPECIAL_MSS), WS(5), NOP, EOL }, /* 9 */
{ MSS(SPECIAL_MSS), WS(5), SOK, NOP, EOL }, /* 12 */
{ MSS(SPECIAL_MSS), TS(1337, 0), NOP, EOL }, /* 17 */
{ MSS(SPECIAL_MSS), SOK, TS(1337, 0), NOP, EOL }, /* 19 */
{ MSS(SPECIAL_MSS), WS(5), TS(1337, 0), NOP, EOL }, /* 20 */
{ MSS(SPECIAL_MSS), WS(5), SOK, TS(1337, 0), NOP, EOL } /* 22 */
};
int main(int argc, char** argv) {
static struct sockaddr_in6 sin;
char one = 1;
s32 sock;
u32 i;
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) ;
}
