/* * Bulk transfer routine -- * used by getfl(), cu_take(), and pipefile() */ static void transfer(char *buf, int fd, char *eofchars) { int ct, eof; char c, buffer[BUFSIZ]; char *p = buffer; size_t cnt; time_t start; sig_t f; char r; if (number(value(FRAMESIZE)) > BUFSIZ || number(value(FRAMESIZE)) < 1) { printf("framesize must be >= 1 and <= %d\r\n", BUFSIZ); close(fd); return; } parwrite(FD, buf, size(buf)); quit = 0; kill(tipout_pid, SIGIOT); read(repdes[0], (char *)&ccc, 1); /* Wait until read process stops */ /* * finish command */ r = '\r'; parwrite(FD, &r, 1); do read(FD, &c, 1); while ((c&STRIP_PAR) != '\n'); tcsetattr(0, TCSAFLUSH, &defchars); (void) setjmp(intbuf); f = signal(SIGINT, intcopy); start = time(0); for (ct = 0; !quit;) { eof = read(FD, &c, 1) <= 0; c &= STRIP_PAR; if (quit) continue; if (eof || any(c, eofchars)) break; if (c == 0) continue; /* ignore nulls */ if (c == '\r') continue; *p++ = c; if (c == '\n' && boolean(value(VERBOSE))) printf("\r%d", ++ct); if ((cnt = (p-buffer)) == (size_t)number(value(FRAMESIZE))) { if ((size_t)write(fd, buffer, cnt) != cnt) { printf("\r\nwrite error\r\n"); quit = 1; } p = buffer; } } if ((cnt = (p-buffer))) if ((size_t)write(fd, buffer, cnt) != cnt) printf("\r\nwrite error\r\n"); if (boolean(value(VERBOSE))) prtime(" lines transferred in ", time(0)-start); tcsetattr(0, TCSAFLUSH, &term); write(fildes[1], (char *)&ccc, 1); signal(SIGINT, f); close(fd); }
static int tglob(register char c) { if (any(c, globchars)) gflag |= c == '{' ? 2 : 1; return (c); }
size_t max_formatted_length(T x) const noexcept { size_t n = details::ndigits_dec(details::uabs(x)); if (x < 0 || any(showpos)) n++; return n; }
bool CompilationCppParser::init_using_dep( CompilationEnvironment &ce, const String &cpp_file, const String &dep_file ) { SI64 date_cpp = last_modification_time_or_zero_of_file_named( cpp_file ); SI64 date_dep = last_modification_time_or_zero_of_file_named( dep_file ); if ( date_cpp > date_dep ) return false; File fd( dep_file, "r" ); const char *c = fd.c_str(); // orig flags are conform ? BasicVec<String> loc_inc_paths; BasicVec<String> loc_def_procs; load_dep_vec( c, loc_inc_paths ); load_dep_vec( c, loc_def_procs ); if ( ce_inc_paths.size() != loc_inc_paths.size() or ce_def_procs.size() != loc_def_procs.size() ) return false; if ( any( ce_inc_paths != loc_inc_paths ) or any( ce_def_procs != loc_def_procs ) ) return false; // include file are older than dep file ? load_dep_vec( c, inc_files ); for( ST i = 0; i < inc_files.size(); ++i ) { if ( last_modification_time_or_zero_of_file_named( inc_files[ i ] ) > date_dep ) { inc_files.resize( 0 ); return false; } } // -> OK load_dep_vec( c, moc_files ); load_dep_vec( c, src_files ); load_dep_vec( c, lib_paths ); load_dep_vec( c, lib_names ); load_dep_vec( c, fra_names ); load_dep_vec( c, inc_paths ); load_dep_vec( c, cpp_flags ); load_dep_vec( c, lnk_flags ); load_dep_vec( c, gpu_flags ); load_dep_vec( c, var_templ ); load_dep_vec( c, cxx_name ); BasicVec<String> defs; load_dep_vec( c, defs ); for( int i = 0; i < defs.size(); ++i ) defines[ defs[ i ] ]; // .h.py ? for( int i = 0; i < inc_files.size(); ++i ) { String inc_file = inc_files[ i ]; if ( inc_file.ends_with( ".h" ) ) { String h_py = inc_file + ".py"; if ( file_exists( h_py ) ) { if ( last_modification_time_or_zero_of_file_named( h_py ) > last_modification_time_or_zero_of_file_named( inc_file ) ) make_h_py( h_py, inc_file ); } } } return true; }
virtual any cast (const any& value) const { return any(anycast<T*>(value)); }
/*ARGSUSED*/ void dolet(Char **v, struct command *dummy) { Char *p; Char *vp, c, op; int hadsub; int subscr; USE(dummy); v++; p = *v++; if (p == 0) { prvars(); return; } do { hadsub = 0; vp = p; if (letter(*p)) for (; alnum(*p); p++) continue; if (vp == p || !letter(*vp)) stderror(ERR_NAME | ERR_VARBEGIN); if (*p == '[') { hadsub++; p = getinx(p, &subscr); } if (*p == 0 && *v) p = *v++; if ((op = *p) != 0) *p++ = 0; else stderror(ERR_NAME | ERR_ASSIGN); /* * if there is no expression after the '=' then print a "Syntax Error" * message - strike */ if (*p == '\0' && *v == NULL) stderror(ERR_NAME | ERR_ASSIGN); vp = Strsave(vp); cleanup_push(vp, xfree); if (op == '=') { c = '='; p = xset(p, &v); } else { c = *p++; if (any("+-", c)) { if (c != op || *p) stderror(ERR_NAME | ERR_UNKNOWNOP); p = Strsave(STR1); } else { if (any("<>", op)) { if (c != op) stderror(ERR_NAME | ERR_UNKNOWNOP); stderror(ERR_NAME | ERR_SYNTAX); } if (c != '=') stderror(ERR_NAME | ERR_UNKNOWNOP); p = xset(p, &v); } } cleanup_push(p, xfree); if (op == '=') { if (hadsub) asx(vp, subscr, p); else setv(vp, p, VAR_READWRITE); cleanup_ignore(p); } else if (hadsub) { struct varent *gv = getvx(vp, subscr); Char *val; val = operate(op, gv->vec[subscr - 1], p); cleanup_push(val, xfree); asx(vp, subscr, val); cleanup_ignore(val); cleanup_until(val); } else { Char *val; val = operate(op, varval(vp), p); cleanup_push(val, xfree); setv(vp, val, VAR_READWRITE); cleanup_ignore(val); cleanup_until(val); } update_vars(vp); cleanup_until(vp); } while ((p = *v++) != NULL); }
void testVectors() { // 2D float vector { float2 x = float2(2.0f, 3.0f); float2 y = float2(4.0f, 5.0f); float2 z = min(x, y); assert(z.x == 2.0f && z.y == 3.0f); } { float2 x = float2(2.0f, 3.0f); float2 y = float2(4.0f, 5.0f); float2 z = max(x, y); assert(z.x == 4.0f && z.y == 5.0f); } { float2 x = float2(2.0f, 3.0f); float2 y = float2(4.0f, 5.0f); float2 z = x + y; assert(z.x == 6.0f && z.y == 8.0f); } { float2 x = float2(2.0f, 3.0f); float2 y = float2(4.0f, 5.0f); float2 z = x - y; assert(z.x == -2.0f && z.y == -2.0f); } { float2 x = float2(2.0f, 3.0f); float2 z = -x; assert(z.x == -2.0f && z.y == -3.0f); } { float2 x = float2(2.0f, 3.0f); float2 y = float2(4.0f, 5.0f); float2 z = x * y; assert(z.x == 8.0f && z.y == 15.0f); } { float2 x = float2(2.0f, 3.0f); float2 y = float2(4.0f, 5.0f); float2 z = x / y; assert(z.x == (2.0f / 4.0f) && z.y == (3.0f / 5.0f)); } { float2 x = float2(2.0f, 3.0f); float2 y = float2(4.0f, 5.0f); float z = dot(x, y); assert(z == (2.0f * 4.0f) + (3.0f * 5.0f)); } { float2 x = float2(2.0f, 3.0f); float z = length(x); assert(fabs(z - sqrt((2.0f * 2.0f) + (3.0f * 3.0f))) < 0.0001f); } { float2 x = float2(2.0f, 3.0f); float2 z = normalize(x); float l = sqrt((2.0f * 2.0f) + (3.0f * 3.0f)); assert(z.x == 2.0f / l && z.y == 3.0f / l); } { float2 x = float2(2.0f, 3.0f); float2 y = float2(4.0f, 5.0f); bmask2 z = x < y; assert(z[0] == 0xFFFFFFFF && z[1] == 0xFFFFFFFF); } { float2 x = float2(2.0f, 3.0f); float2 y = float2(4.0f, 5.0f); bmask2 z = x <= y; assert(z[0] == 0xFFFFFFFF && z[1] == 0xFFFFFFFF); } { float2 x = float2(2.0f, 3.0f); float2 y = float2(4.0f, 5.0f); bmask2 z = x == y; assert(z[0] == 0x00000000 && z[1] == 0x00000000); } { float2 x = float2(2.0f, 3.0f); float2 y = float2(4.0f, 5.0f); bmask2 z = x != y; assert(z[0] == 0xFFFFFFFF && z[1] == 0xFFFFFFFF); } { float2 x = float2(2.0f, 3.0f); float2 y = float2(4.0f, 5.0f); bmask2 z = x >= y; assert(z[0] == 0x00000000 && z[1] == 0x00000000); } { float2 x = float2(2.0f, 3.0f); float2 y = float2(4.0f, 5.0f); bmask2 z = x > y; assert(z[0] == 0x00000000 && z[1] == 0x00000000); } { float2 x = float2(2.0f, 3.0f); float2 y = shuffle<2, 0, 0, 0, 0>(x); float2 z = shuffle<2, 1, 1, 1, 1>(x); assert(y.x == 2.0f && y.y == 2.0f && z.x == 3.0f && z.y == 3.0f); } // 3D float vector { float3 x = float3(2.0f, 3.0f, 4.0f); float3 y = float3(5.0f, 6.0f, 7.0f); float3 z = min(x, y); assert(z.x == 2.0f && z.y == 3.0f && z.z == 4.0f); } { float3 x = float3(2.0f, 3.0f, 4.0f); float3 y = float3(5.0f, 6.0f, 7.0f); float3 z = max(x, y); assert(z.x == 5.0f && z.y == 6.0f && z.z == 7.0f); } { float3 x = float3(2.0f, 3.0f, 4.0f); float3 y = float3(5.0f, 6.0f, 7.0f); float3 z = x + y; assert(z.x == 7.0f && z.y == 9.0f && z.z == 11.0f); } { float3 x = float3(2.0f, 3.0f, 4.0f); float3 y = float3(5.0f, 6.0f, 7.0f); float3 z = x - y; assert(z.x == -3.0f && z.y == -3.0f && z.z == -3.0f); } { float3 x = float3(2.0f, 3.0f, 4.0f); float3 z = -x; assert(z.x == -2.0f && z.y == -3.0f && z.z == -4.0f); } { float3 x = float3(2.0f, 3.0f, 4.0f); float3 y = float3(5.0f, 6.0f, 7.0f); float3 z = x * y; assert(z.x == 10.0f && z.y == 18.0f && z.z == 28.0f); } { float3 x = float3(2.0f, 3.0f, 4.0f); float3 y = float3(5.0f, 6.0f, 7.0f); float3 z = x / y; assert(z.x == (2.0f / 5.0f) && z.y == (3.0f / 6.0f) && z.z == (4.0f / 7.0f)); } { float3 x = float3(2.0f, 3.0f, 4.0f); float3 y = float3(5.0f, 6.0f, 7.0f); float z = dot(x, y); assert(z == (2.0f * 5.0f) + (3.0f * 6.0f) + (4.0f * 7.0f)); } { float3 x = float3(2.0f, 3.0f, 4.0f); float z = length(x); assert(fabs(z - sqrt((2.0f * 2.0f) + (3.0f * 3.0f) + (4.0f * 4.0f))) < 0.0001f); } { float3 x = float3(2.0f, 3.0f, 4.0f); float3 z = normalize(x); float l = sqrt((2.0f * 2.0f) + (3.0f * 3.0f) + (4.0f * 4.0f)); assert(z.x == 2.0f / l && z.y == 3.0f / l && z.z == 4.0f / l); } { float3 x = float3(2.0f, 3.0f, 4.0f); float3 y = float3(5.0f, 6.0f, 7.0f); bmask3 z = x < y; assert(z[0] == 0xFFFFFFFF && z[1] == 0xFFFFFFFF && z[2] == 0xFFFFFFFF); } { float3 x = float3(2.0f, 3.0f, 4.0f); float3 y = float3(5.0f, 6.0f, 7.0f); bmask3 z = x <= y; assert(z[0] == 0xFFFFFFFF && z[1] == 0xFFFFFFFF && z[2] == 0xFFFFFFFF); } { float3 x = float3(2.0f, 3.0f, 4.0f); float3 y = float3(5.0f, 6.0f, 7.0f); bmask3 z = x == y; assert(z[0] == 0x00000000 && z[1] == 0x00000000 && z[2] == 0x00000000); } { float3 x = float3(2.0f, 3.0f, 4.0f); float3 y = float3(5.0f, 6.0f, 7.0f); bmask3 z = x != y; assert(z[0] == 0xFFFFFFFF && z[1] == 0xFFFFFFFF && z[2] == 0xFFFFFFFF); } { float3 x = float3(2.0f, 3.0f, 4.0f); float3 y = float3(5.0f, 6.0f, 7.0f); bmask3 z = x >= y; assert(z[0] == 0x00000000 && z[1] == 0x00000000 && z[2] == 0x00000000); } { float3 x = float3(2.0f, 3.0f, 4.0f); float3 y = float3(5.0f, 6.0f, 7.0f); bmask3 z = x > y; assert(z[0] == 0x00000000 && z[1] == 0x00000000 && z[2] == 0x00000000); } // 4D float vector { float4 x = float4(2.0f, 3.0f, 4.0f, 5.0f); float4 y = float4(6.0f, 7.0f, 8.0f, 9.0f); float4 z = min(x, y); assert(z.x == 2.0f && z.y == 3.0f && z.z == 4.0f && z.w == 5.0f); } { float4 x = float4(2.0f, 3.0f, 4.0f, 5.0f); float4 y = float4(6.0f, 7.0f, 8.0f, 9.0f); float4 z = max(x, y); assert(z.x == 6.0f && z.y == 7.0f && z.z == 8.0f && z.w == 9.0f); } { float4 x = float4(2.0f, 3.0f, 4.0f, 5.0f); float4 y = float4(6.0f, 7.0f, 8.0f, 9.0f); float4 z = x + y; assert(z.x == 8.0f && z.y == 10.0f && z.z == 12.0f && z.w == 14.0f); } { float4 x = float4(2.0f, 3.0f, 4.0f, 5.0f); float4 y = float4(6.0f, 7.0f, 8.0f, 9.0f); float4 z = x - y; assert(z.x == -4.0f && z.y == -4.0f && z.z == -4.0f && z.w == -4.0f); } { float4 x = float4(2.0f, 3.0f, 4.0f, 5.0f); float4 z = -x; assert(z.x == -2.0f && z.y == -3.0f && z.z == -4.0f && z.w == -5.0f); } { float4 x = float4(2.0f, 3.0f, 4.0f, 5.0f); float4 y = float4(6.0f, 7.0f, 8.0f, 9.0f); float4 z = x * y; assert(z.x == 12.0f && z.y == 21.0f && z.z == 32.0f && z.w == 45.0f); } { float4 x = float4(2.0f, 3.0f, 4.0f, 5.0f); float4 y = float4(6.0f, 7.0f, 8.0f, 9.0f); float4 z = x / y; assert(z.x == (2.0f / 6.0f) && z.y == (3.0f / 7.0f) && z.z == (4.0f / 8.0f) && z.w == (5.0f / 9.0f)); } { float4 x = float4(2.0f, 3.0f, 4.0f, 5.0f); float4 y = float4(6.0f, 7.0f, 8.0f, 9.0f); float z = dot(x, y); assert(z == (2.0f * 6.0f) + (3.0f * 7.0f) + (4.0f * 8.0f) + (5.0f * 9.0f)); } { float4 x = float4(2.0f, 3.0f, 4.0f, 5.0f); float z = length(x); assert(fabs(z - sqrt((2.0f * 2.0f) + (3.0f * 3.0f) + (4.0f * 4.0f) + (5.0f * 5.0f))) < 0.0001f); } { float4 x = float4(2.0f, 3.0f, 4.0f, 5.0f); float4 z = normalize(x); float l = sqrt((2.0f * 2.0f) + (3.0f * 3.0f) + (4.0f * 4.0f) + (5.0f * 5.0f)); assert(z.x == 2.0f / l && z.y == 3.0f / l && z.z == 4.0f / l && z.w == 5.0f / l); } { float4 x = float4(2.0f, 3.0f, 4.0f, 5.0f); float4 y = float4(6.0f, 7.0f, 8.0f, 9.0f); bmask4 z = x < y; assert(z[0] == 0xFFFFFFFF && z[1] == 0xFFFFFFFF && z[2] == 0xFFFFFFFF && z[3] == 0xFFFFFFFF); } { float4 x = float4(2.0f, 3.0f, 4.0f, 5.0f); float4 y = float4(6.0f, 7.0f, 8.0f, 9.0f); bmask4 z = x <= y; assert(z[0] == 0xFFFFFFFF && z[1] == 0xFFFFFFFF && z[2] == 0xFFFFFFFF && z[3] == 0xFFFFFFFF); } { float4 x = float4(2.0f, 3.0f, 4.0f, 5.0f); float4 y = float4(6.0f, 7.0f, 8.0f, 9.0f); bmask4 z = x == y; assert(z[0] == 0x00000000 && z[1] == 0x00000000 && z[2] == 0x00000000 && z[3] == 0x00000000); } { float4 x = float4(2.0f, 3.0f, 4.0f, 5.0f); float4 y = float4(6.0f, 7.0f, 8.0f, 9.0f); bmask4 z = x != y; assert(z[0] == 0xFFFFFFFF && z[1] == 0xFFFFFFFF && z[2] == 0xFFFFFFFF && z[3] == 0xFFFFFFFF); } { float4 x = float4(2.0f, 3.0f, 4.0f, 5.0f); float4 y = float4(6.0f, 7.0f, 8.0f, 9.0f); bmask4 z = x >= y; assert(z[0] == 0x00000000 && z[1] == 0x00000000 && z[2] == 0x00000000 && z[3] == 0x00000000); } { float4 x = float4(2.0f, 3.0f, 4.0f, 5.0f); float4 y = float4(6.0f, 7.0f, 8.0f, 9.0f); bmask4 z = x > y; assert(z[0] == 0x00000000 && z[1] == 0x00000000 && z[2] == 0x00000000 && z[3] == 0x00000000); } // 2D bitmask { bmask2 y = bmask2(0xFFFF0000); bmask2 z = ~y; assert(z[0] == 0x0000FFFF && z[1] == 0x0000FFFF); } { bmask2 x = bmask2(0x00000010); bmask2 y = bmask2(0x00000001); bmask2 z = x | y; assert(z[0] == 0x00000011 && z[1] == 0x00000011); } { bmask2 x = bmask2(0x00000110); bmask2 y = bmask2(0x00000011); bmask2 z = x & y; assert(z[0] == 0x00000010 && z[1] == 0x00000010); } { bmask2 x = bmask2(0x00000000, 0xFFFFFFFF); float2 y = float2(1.0f); float2 z = float2(2.0f); float2 w = blend(x, y, z); assert(w.x == 1.0f && w.y == 2.0f); } { bmask4 x = bmask4(0x00000000, 0xFFFFFFFF, 0x00000000, 0xFFFFFFFF); int4 y = int4(1); int4 z = int4(2); int4 w = blend(x, y, z); assert(w.x == 1 && w.y == 2 && w.z == 1 && w.w == 2); } { bmask4 x = bmask4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF); bmask4 y = bmask4(0xFFFFFFFF, 0xFFFFFFFF, 0x00000000, 0x00000000); bmask4 z = bmask4(0x00000000, 0x00000000, 0x00000000, 0x00000000); assert(any(x)); assert(any(y)); assert(!any(z)); assert(all(x)); assert(!all(y)); assert(!all(z)); } }
/* * Get the argument words for a command into genbuf * expanding # and %. */ int getargs(void) { register int c; register char *cp, *fp; static char fpatbuf[32]; /* hence limit on :next +/pat */ pastwh(); if (peekchar() == '+') { for (cp = fpatbuf;;) { c = *cp++ = ex_getchar(); if (cp >= &fpatbuf[sizeof(fpatbuf)]) error("Pattern too long"); if (c == '\\' && isspace(peekchar())) c = ex_getchar(); if (c == EOF || isspace(c)) { ungetchar(c); *--cp = 0; firstpat = &fpatbuf[1]; break; } } } if (skipend()) return (0); CP(genbuf, "echo "); cp = &genbuf[5]; for (;;) { c = ex_getchar(); if (endcmd(c)) { ungetchar(c); break; } switch (c) { case '\\': if (any(peekchar(), "#%|")) c = ex_getchar(); /* fall into... */ default: if (cp > &genbuf[LBSIZE - 2]) flong: error("Argument buffer overflow"); *cp++ = c; break; case '#': fp = altfile; if (*fp == 0) error("No alternate filename@to substitute for #"); goto filexp; case '%': fp = savedfile; if (*fp == 0) error("No current filename@to substitute for %%"); filexp: while (*fp) { if (cp > &genbuf[LBSIZE - 2]) goto flong; *cp++ = *fp++; } break; } } *cp = 0; return (1); }
void BVH4Intersector4Chunk<PrimitiveIntersector4>::intersect(sseb* valid_i, BVH4* bvh, Ray4& ray) { /* load ray */ const sseb valid0 = *valid_i; const sse3f rdir = rcp_safe(ray.dir); const sse3f org(ray.org), org_rdir = org * rdir; ssef ray_tnear = select(valid0,ray.tnear,ssef(pos_inf)); ssef ray_tfar = select(valid0,ray.tfar ,ssef(neg_inf)); const ssef inf = ssef(pos_inf); Precalculations pre(valid0,ray); /* allocate stack and push root node */ ssef stack_near[stackSize]; NodeRef stack_node[stackSize]; stack_node[0] = BVH4::invalidNode; stack_near[0] = inf; stack_node[1] = bvh->root; stack_near[1] = ray_tnear; NodeRef* stackEnd = stack_node+stackSize; NodeRef* __restrict__ sptr_node = stack_node + 2; ssef* __restrict__ sptr_near = stack_near + 2; while (1) { /* pop next node from stack */ assert(sptr_node > stack_node); sptr_node--; sptr_near--; NodeRef curNode = *sptr_node; if (unlikely(curNode == BVH4::invalidNode)) { assert(sptr_node == stack_node); break; } /* cull node if behind closest hit point */ ssef curDist = *sptr_near; if (unlikely(none(ray_tfar > curDist))) continue; while (1) { /* test if this is a leaf node */ if (unlikely(curNode.isLeaf())) break; const sseb valid_node = ray_tfar > curDist; STAT3(normal.trav_nodes,1,popcnt(valid_node),4); const Node* __restrict__ const node = curNode.node(); /* pop of next node */ assert(sptr_node > stack_node); sptr_node--; sptr_near--; curNode = *sptr_node; curDist = *sptr_near; #pragma unroll(4) for (unsigned i=0; i<BVH4::N; i++) { const NodeRef child = node->children[i]; if (unlikely(child == BVH4::emptyNode)) break; #if defined(__AVX2__) const ssef lclipMinX = msub(node->lower_x[i],rdir.x,org_rdir.x); const ssef lclipMinY = msub(node->lower_y[i],rdir.y,org_rdir.y); const ssef lclipMinZ = msub(node->lower_z[i],rdir.z,org_rdir.z); const ssef lclipMaxX = msub(node->upper_x[i],rdir.x,org_rdir.x); const ssef lclipMaxY = msub(node->upper_y[i],rdir.y,org_rdir.y); const ssef lclipMaxZ = msub(node->upper_z[i],rdir.z,org_rdir.z); #else const ssef lclipMinX = (node->lower_x[i] - org.x) * rdir.x; const ssef lclipMinY = (node->lower_y[i] - org.y) * rdir.y; const ssef lclipMinZ = (node->lower_z[i] - org.z) * rdir.z; const ssef lclipMaxX = (node->upper_x[i] - org.x) * rdir.x; const ssef lclipMaxY = (node->upper_y[i] - org.y) * rdir.y; const ssef lclipMaxZ = (node->upper_z[i] - org.z) * rdir.z; #endif #if defined(__SSE4_1__) const ssef lnearP = maxi(maxi(mini(lclipMinX, lclipMaxX), mini(lclipMinY, lclipMaxY)), mini(lclipMinZ, lclipMaxZ)); const ssef lfarP = mini(mini(maxi(lclipMinX, lclipMaxX), maxi(lclipMinY, lclipMaxY)), maxi(lclipMinZ, lclipMaxZ)); const sseb lhit = maxi(lnearP,ray_tnear) <= mini(lfarP,ray_tfar); #else const ssef lnearP = max(max(min(lclipMinX, lclipMaxX), min(lclipMinY, lclipMaxY)), min(lclipMinZ, lclipMaxZ)); const ssef lfarP = min(min(max(lclipMinX, lclipMaxX), max(lclipMinY, lclipMaxY)), max(lclipMinZ, lclipMaxZ)); const sseb lhit = max(lnearP,ray_tnear) <= min(lfarP,ray_tfar); #endif /* if we hit the child we choose to continue with that child if it is closer than the current next child, or we push it onto the stack */ if (likely(any(lhit))) { assert(sptr_node < stackEnd); const ssef childDist = select(lhit,lnearP,inf); const NodeRef child = node->children[i]; assert(child != BVH4::emptyNode); sptr_node++; sptr_near++; /* push cur node onto stack and continue with hit child */ if (any(childDist < curDist)) { *(sptr_node-1) = curNode; *(sptr_near-1) = curDist; curDist = childDist; curNode = child; } /* push hit child onto stack */ else { *(sptr_node-1) = child; *(sptr_near-1) = childDist; } } } } /* return if stack is empty */ if (unlikely(curNode == BVH4::invalidNode)) { assert(sptr_node == stack_node); break; } /* intersect leaf */ const sseb valid_leaf = ray_tfar > curDist; STAT3(normal.trav_leaves,1,popcnt(valid_leaf),4); size_t items; const Primitive* prim = (Primitive*) curNode.leaf(items); PrimitiveIntersector4::intersect(valid_leaf,pre,ray,prim,items,bvh->geometry); ray_tfar = select(valid_leaf,ray.tfar,ray_tfar); } AVX_ZERO_UPPER(); }
void BVH8Intersector8Hybrid<PrimitiveIntersector8>::occluded(bool8* valid_i, BVH8* bvh, Ray8& ray) { /* load ray */ const bool8 valid = *valid_i; bool8 terminated = !valid; Vec3f8 ray_org = ray.org, ray_dir = ray.dir; float8 ray_tnear = ray.tnear, ray_tfar = ray.tfar; const Vec3f8 rdir = rcp_safe(ray_dir); const Vec3f8 org(ray_org), org_rdir = org * rdir; ray_tnear = select(valid,ray_tnear,float8(pos_inf)); ray_tfar = select(valid,ray_tfar ,float8(neg_inf)); const float8 inf = float8(pos_inf); Precalculations pre(valid,ray); /* compute near/far per ray */ Vec3i8 nearXYZ; nearXYZ.x = select(rdir.x >= 0.0f,int8(0*(int)sizeof(float8)),int8(1*(int)sizeof(float8))); nearXYZ.y = select(rdir.y >= 0.0f,int8(2*(int)sizeof(float8)),int8(3*(int)sizeof(float8))); nearXYZ.z = select(rdir.z >= 0.0f,int8(4*(int)sizeof(float8)),int8(5*(int)sizeof(float8))); /* allocate stack and push root node */ float8 stack_near[stackSizeChunk]; NodeRef stack_node[stackSizeChunk]; stack_node[0] = BVH8::invalidNode; stack_near[0] = inf; stack_node[1] = bvh->root; stack_near[1] = ray_tnear; NodeRef* stackEnd = stack_node+stackSizeChunk; NodeRef* __restrict__ sptr_node = stack_node + 2; float8* __restrict__ sptr_near = stack_near + 2; while (1) { /* pop next node from stack */ assert(sptr_node > stack_node); sptr_node--; sptr_near--; NodeRef cur = *sptr_node; if (unlikely(cur == BVH8::invalidNode)) { assert(sptr_node == stack_node); break; } /* cull node if behind closest hit point */ float8 curDist = *sptr_near; const bool8 active = curDist < ray_tfar; if (unlikely(none(active))) continue; /* switch to single ray traversal */ #if !defined(__WIN32__) || defined(__X86_64__) size_t bits = movemask(active); if (unlikely(__popcnt(bits) <= SWITCH_THRESHOLD)) { for (size_t i=__bsf(bits); bits!=0; bits=__btc(bits,i), i=__bsf(bits)) { if (occluded1(bvh,cur,i,pre,ray,ray_org,ray_dir,rdir,ray_tnear,ray_tfar,nearXYZ)) terminated[i] = -1; } if (all(terminated)) break; ray_tfar = select(terminated,float8(neg_inf),ray_tfar); continue; } #endif while (1) { /* test if this is a leaf node */ if (unlikely(cur.isLeaf())) break; const bool8 valid_node = ray_tfar > curDist; STAT3(shadow.trav_nodes,1,popcnt(valid_node),8); const Node* __restrict__ const node = (Node*)cur.node(); /* pop of next node */ assert(sptr_node > stack_node); sptr_node--; sptr_near--; cur = *sptr_node; curDist = *sptr_near; for (unsigned i=0; i<BVH8::N; i++) { const NodeRef child = node->children[i]; if (unlikely(child == BVH8::emptyNode)) break; #if defined(__AVX2__) const float8 lclipMinX = msub(node->lower_x[i],rdir.x,org_rdir.x); const float8 lclipMinY = msub(node->lower_y[i],rdir.y,org_rdir.y); const float8 lclipMinZ = msub(node->lower_z[i],rdir.z,org_rdir.z); const float8 lclipMaxX = msub(node->upper_x[i],rdir.x,org_rdir.x); const float8 lclipMaxY = msub(node->upper_y[i],rdir.y,org_rdir.y); const float8 lclipMaxZ = msub(node->upper_z[i],rdir.z,org_rdir.z); const float8 lnearP = maxi(maxi(mini(lclipMinX, lclipMaxX), mini(lclipMinY, lclipMaxY)), mini(lclipMinZ, lclipMaxZ)); const float8 lfarP = mini(mini(maxi(lclipMinX, lclipMaxX), maxi(lclipMinY, lclipMaxY)), maxi(lclipMinZ, lclipMaxZ)); const bool8 lhit = maxi(lnearP,ray_tnear) <= mini(lfarP,ray_tfar); #else const float8 lclipMinX = (node->lower_x[i] - org.x) * rdir.x; const float8 lclipMinY = (node->lower_y[i] - org.y) * rdir.y; const float8 lclipMinZ = (node->lower_z[i] - org.z) * rdir.z; const float8 lclipMaxX = (node->upper_x[i] - org.x) * rdir.x; const float8 lclipMaxY = (node->upper_y[i] - org.y) * rdir.y; const float8 lclipMaxZ = (node->upper_z[i] - org.z) * rdir.z; const float8 lnearP = max(max(min(lclipMinX, lclipMaxX), min(lclipMinY, lclipMaxY)), min(lclipMinZ, lclipMaxZ)); const float8 lfarP = min(min(max(lclipMinX, lclipMaxX), max(lclipMinY, lclipMaxY)), max(lclipMinZ, lclipMaxZ)); const bool8 lhit = max(lnearP,ray_tnear) <= min(lfarP,ray_tfar); #endif /* if we hit the child we choose to continue with that child if it is closer than the current next child, or we push it onto the stack */ if (likely(any(lhit))) { assert(sptr_node < stackEnd); assert(child != BVH8::emptyNode); const float8 childDist = select(lhit,lnearP,inf); sptr_node++; sptr_near++; /* push cur node onto stack and continue with hit child */ if (any(childDist < curDist)) { *(sptr_node-1) = cur; *(sptr_near-1) = curDist; curDist = childDist; cur = child; } /* push hit child onto stack */ else { *(sptr_node-1) = child; *(sptr_near-1) = childDist; } } } } /* return if stack is empty */ if (unlikely(cur == BVH8::invalidNode)) { assert(sptr_node == stack_node); break; } /* intersect leaf */ assert(cur != BVH8::emptyNode); const bool8 valid_leaf = ray_tfar > curDist; STAT3(shadow.trav_leaves,1,popcnt(valid_leaf),8); size_t items; const Triangle* prim = (Triangle*) cur.leaf(items); terminated |= PrimitiveIntersector8::occluded(!terminated,pre,ray,prim,items,bvh->scene); if (all(terminated)) break; ray_tfar = select(terminated,float8(neg_inf),ray_tfar); } store8i(valid & terminated,&ray.geomID,0); AVX_ZERO_UPPER(); }
void wxAnyTestCase::wxVariantConversions() { #if wxUSE_VARIANT // // Test various conversions to and from wxVariant // bool res; // Prepare wxVariants wxVariant vLong(123L); wxVariant vString("ABC"); wxVariant vDouble(TEST_FLOAT_CONST); wxVariant vBool((bool)true); wxVariant vChar('A'); #ifdef wxLongLong_t wxVariant vLongLong(wxLongLong(wxLL(0xAABBBBCCCC))); wxVariant vULongLong(wxULongLong(wxULL(123456))); #endif wxArrayString arrstr; arrstr.push_back("test string"); wxVariant vArrayString(arrstr); wxVariant vDateTime(m_testDateTime); wxVariant vVoidPtr(dummyVoidPointer); wxVariant vCustomType(new wxMyVariantData(MyClass(101))); wxVariant vList; vList.NullList(); vList.Append(15); vList.Append("abc"); // Convert to wxAnys, and then back to wxVariants wxVariant variant; wxAny any(vLong); CPPUNIT_ASSERT(any == 123L); res = any.GetAs(&variant); CPPUNIT_ASSERT(res); CPPUNIT_ASSERT(variant == 123L); // Make sure integer variant has correct type information CPPUNIT_ASSERT(variant.GetLong() == 123); CPPUNIT_ASSERT(variant.GetType() == "long"); // Unsigned long wxAny should convert to "ulonglong" wxVariant any = 1000UL; res = any.GetAs(&variant); CPPUNIT_ASSERT(res); CPPUNIT_ASSERT(variant.GetType() == "ulonglong"); CPPUNIT_ASSERT(variant.GetLong() == 1000); any = vString; CPPUNIT_ASSERT(any == "ABC"); res = any.GetAs(&variant); CPPUNIT_ASSERT(res); CPPUNIT_ASSERT(variant.GetString() == "ABC"); // Must be able to build string wxVariant from wxAny built from // string literal any = "ABC"; res = any.GetAs(&variant); CPPUNIT_ASSERT(res); CPPUNIT_ASSERT(variant.GetType() == "string"); CPPUNIT_ASSERT(variant.GetString() == "ABC"); any = L"ABC"; res = any.GetAs(&variant); CPPUNIT_ASSERT(res); CPPUNIT_ASSERT(variant.GetType() == "string"); #if wxUSE_UNICODE CPPUNIT_ASSERT(variant.GetString() == L"ABC"); #endif any = vDouble; double d = wxANY_AS(any, double); CPPUNIT_ASSERT_DOUBLES_EQUAL(d, TEST_FLOAT_CONST, FEQ_DELTA); res = any.GetAs(&variant); CPPUNIT_ASSERT(res); CPPUNIT_ASSERT_DOUBLES_EQUAL(variant.GetDouble(), TEST_FLOAT_CONST, FEQ_DELTA); any = vBool; CPPUNIT_ASSERT(wxANY_AS(any, bool) == true); res = any.GetAs(&variant); CPPUNIT_ASSERT(res); CPPUNIT_ASSERT(variant.GetBool() == true); any = wxAny(vChar); //CPPUNIT_ASSERT(wxANY_AS(any, wxUniChar) == 'A'); res = any.GetAs(&variant); CPPUNIT_ASSERT(res); CPPUNIT_ASSERT(variant.GetChar() == 'A'); #ifdef wxLongLong_t any = wxAny(vLongLong); CPPUNIT_ASSERT(any == wxLL(0xAABBBBCCCC)); res = any.GetAs(&variant); CPPUNIT_ASSERT(res); CPPUNIT_ASSERT(variant.GetType() == "longlong"); CPPUNIT_ASSERT(variant.GetLongLong() == wxLongLong(wxLL(0xAABBBBCCCC))); #if LONG_MAX == wxINT64_MAX // As a sanity check, test that wxVariant of type 'long' converts // seamlessly to 'longlong' (on some 64-bit systems) any = 0xAABBBBCCCCL; res = any.GetAs(&variant); CPPUNIT_ASSERT(variant.GetLongLong() == wxLongLong(wxLL(0xAABBBBCCCC))); #endif any = wxAny(vULongLong); CPPUNIT_ASSERT(any == wxLL(123456)); res = any.GetAs(&variant); CPPUNIT_ASSERT(res); CPPUNIT_ASSERT(variant.GetType() == "ulonglong"); CPPUNIT_ASSERT(variant.GetULongLong() == wxULongLong(wxULL(123456))); #endif // Cannot test equality for the rest, just test that they convert // back correctly. any = wxAny(vArrayString); res = any.GetAs(&variant); CPPUNIT_ASSERT(res); wxArrayString arrstr2 = variant.GetArrayString(); CPPUNIT_ASSERT(arrstr2 == arrstr); any = m_testDateTime; CPPUNIT_ASSERT(wxANY_AS(any, wxDateTime) == m_testDateTime); any = wxAny(vDateTime); CPPUNIT_ASSERT(wxANY_AS(any, wxDateTime) == m_testDateTime); res = any.GetAs(&variant); CPPUNIT_ASSERT(res); CPPUNIT_ASSERT(variant == m_testDateTime); any = wxAny(vVoidPtr); res = any.GetAs(&variant); CPPUNIT_ASSERT(res); CPPUNIT_ASSERT(variant.GetVoidPtr() == dummyVoidPointer); any = wxAny(vList); CPPUNIT_ASSERT(wxANY_CHECK_TYPE(any, wxAnyList)); wxAnyList anyList = wxANY_AS(any, wxAnyList); CPPUNIT_ASSERT(anyList.GetCount() == 2); CPPUNIT_ASSERT(wxANY_AS((*anyList[0]), int) == 15); CPPUNIT_ASSERT(wxANY_AS((*anyList[1]), wxString) == "abc"); res = any.GetAs(&variant); CPPUNIT_ASSERT(res); CPPUNIT_ASSERT(variant.GetType() == "list"); CPPUNIT_ASSERT(variant.GetCount() == 2); CPPUNIT_ASSERT(variant[0].GetLong() == 15); CPPUNIT_ASSERT(variant[1].GetString() == "abc"); any = wxAny(vCustomType); CPPUNIT_ASSERT(wxANY_CHECK_TYPE(any, wxVariantData*)); res = any.GetAs(&variant); CPPUNIT_ASSERT(res); CPPUNIT_ASSERT(variant.GetType() == "MyClass"); #endif // wxUSE_VARIANT }
void BVH4Intersector4Chunk<types,robust,PrimitiveIntersector4>::intersect(sseb* valid_i, BVH4* bvh, Ray4& ray) { /* load ray */ const sseb valid0 = *valid_i; const sse3f rdir = rcp_safe(ray.dir); const sse3f org(ray.org), org_rdir = org * rdir; ssef ray_tnear = select(valid0,ray.tnear,ssef(pos_inf)); ssef ray_tfar = select(valid0,ray.tfar ,ssef(neg_inf)); const ssef inf = ssef(pos_inf); Precalculations pre(valid0,ray); /* allocate stack and push root node */ ssef stack_near[stackSize]; NodeRef stack_node[stackSize]; stack_node[0] = BVH4::invalidNode; stack_near[0] = inf; stack_node[1] = bvh->root; stack_near[1] = ray_tnear; NodeRef* stackEnd = stack_node+stackSize; NodeRef* __restrict__ sptr_node = stack_node + 2; ssef* __restrict__ sptr_near = stack_near + 2; while (1) { /* pop next node from stack */ assert(sptr_node > stack_node); sptr_node--; sptr_near--; NodeRef cur = *sptr_node; if (unlikely(cur == BVH4::invalidNode)) { assert(sptr_node == stack_node); break; } /* cull node if behind closest hit point */ ssef curDist = *sptr_near; if (unlikely(none(ray_tfar > curDist))) continue; while (1) { /* process normal nodes */ if (likely((types & 0x1) && cur.isNode())) { const sseb valid_node = ray_tfar > curDist; STAT3(normal.trav_nodes,1,popcnt(valid_node),8); const Node* __restrict__ const node = cur.node(); /* pop of next node */ assert(sptr_node > stack_node); sptr_node--; sptr_near--; cur = *sptr_node; curDist = *sptr_near; #pragma unroll(4) for (unsigned i=0; i<BVH4::N; i++) { const NodeRef child = node->children[i]; if (unlikely(child == BVH4::emptyNode)) break; ssef lnearP; const sseb lhit = node->intersect<robust>(i,org,rdir,org_rdir,ray_tnear,ray_tfar,lnearP); /* if we hit the child we choose to continue with that child if it is closer than the current next child, or we push it onto the stack */ if (likely(any(lhit))) { assert(sptr_node < stackEnd); const ssef childDist = select(lhit,lnearP,inf); const NodeRef child = node->children[i]; assert(child != BVH4::emptyNode); sptr_node++; sptr_near++; /* push cur node onto stack and continue with hit child */ if (any(childDist < curDist)) { *(sptr_node-1) = cur; *(sptr_near-1) = curDist; curDist = childDist; cur = child; } /* push hit child onto stack */ else { *(sptr_node-1) = child; *(sptr_near-1) = childDist; } } } } /* process motion blur nodes */ else if (likely((types & 0x10) && cur.isNodeMB())) { const sseb valid_node = ray_tfar > curDist; STAT3(normal.trav_nodes,1,popcnt(valid_node),8); const BVH4::NodeMB* __restrict__ const node = cur.nodeMB(); /* pop of next node */ assert(sptr_node > stack_node); sptr_node--; sptr_near--; cur = *sptr_node; curDist = *sptr_near; #pragma unroll(4) for (unsigned i=0; i<BVH4::N; i++) { const NodeRef child = node->child(i); if (unlikely(child == BVH4::emptyNode)) break; ssef lnearP; const sseb lhit = node->intersect(i,org,rdir,org_rdir,ray_tnear,ray_tfar,ray.time,lnearP); /* if we hit the child we choose to continue with that child if it is closer than the current next child, or we push it onto the stack */ if (likely(any(lhit))) { assert(sptr_node < stackEnd); assert(child != BVH4::emptyNode); const ssef childDist = select(lhit,lnearP,inf); sptr_node++; sptr_near++; /* push cur node onto stack and continue with hit child */ if (any(childDist < curDist)) { *(sptr_node-1) = cur; *(sptr_near-1) = curDist; curDist = childDist; cur = child; } /* push hit child onto stack */ else { *(sptr_node-1) = child; *(sptr_near-1) = childDist; } } } } else break; }
main() { char *s1 = "hello world"; char *s2 = "ol"; printf("%s in %s %d\n", s2, s1, any(s1, s2)); }
inline bool in(IterType begin, IterType end, const T& elem) { return any(begin, end, boost::bind(std::equal_to<T>(), elem, _1)); }
void merge_same_types (const basic_string_token &rhs_, basic_string_token &merged_) const { if (any ()) { merged_._negated = true; } else if (_negated) { typename string::const_iterator iter_ = _chars.begin (); typename string::const_iterator end_ = _chars.end (); typename string::const_iterator rhs_iter_ = rhs_._chars.begin (); typename string::const_iterator rhs_end_ = rhs_._chars.end (); merged_._negated = _negated; while (iter_ != end_ && rhs_iter_ != rhs_end_) { if (*iter_ < *rhs_iter_) { ++iter_; } else if (*iter_ > *rhs_iter_) { ++rhs_iter_; } else { merged_._chars += *iter_; ++iter_; ++rhs_iter_; } } merged_.normalise (); } else { typename string::const_iterator iter_ = _chars.begin (); typename string::const_iterator end_ = _chars.end (); typename string::const_iterator rhs_iter_ = rhs_._chars.begin (); typename string::const_iterator rhs_end_ = rhs_._chars.end (); while (iter_ != end_ && rhs_iter_ != rhs_end_) { if (*iter_ < *rhs_iter_) { merged_._chars += *iter_; ++iter_; } else if (*iter_ > *rhs_iter_) { merged_._chars += *rhs_iter_; ++rhs_iter_; } else { merged_._chars += *iter_; ++iter_; ++rhs_iter_; } } // Include any trailing chars if (iter_ != end_) { string temp_ (iter_, end_); merged_._chars += temp_; } else if (rhs_iter_ != rhs_end_) { string temp_ (rhs_iter_, rhs_end_); merged_._chars += temp_; } merged_.normalise (); } }
/* * syn3 * ( syn0 ) [ < in ] [ > out ] * word word* [ < in ] [ > out ] * KEYWORD ( word* ) word* [ < in ] [ > out ] * * KEYWORD = (@ exit foreach if set switch test while) */ static struct command * syn3(struct wordent *p1, struct wordent *p2, int flags) { struct wordent *p; struct wordent *lp, *rp; struct command *t; int l; Char **av; int n, c; bool specp = 0; if (p1 != p2) { p = p1; again: switch (srchx(p->word)) { case T_ELSE: p = p->next; if (p != p2) goto again; break; case T_EXIT: case T_FOREACH: case T_IF: case T_LET: case T_SET: case T_SWITCH: case T_WHILE: specp = 1; break; } } n = 0; l = 0; for (p = p1; p != p2; p = p->next) switch (p->word[0]) { case '(': if (specp) n++; l++; continue; case ')': if (specp) n++; l--; continue; case '>': case '<': if (l != 0) { if (specp) n++; continue; } if (p->next == p2) continue; if (any(RELPAR, p->next->word[0])) continue; n--; continue; default: if (!specp && l != 0) continue; n++; continue; } if (n < 0) n = 0; t = (struct command *) xcalloc(1, sizeof(*t)); av = (Char **) xcalloc((size_t) (n + 1), sizeof(Char **)); t->t_dcom = av; n = 0; if (p2->word[0] == ')') t->t_dflg = F_NOFORK; lp = 0; rp = 0; l = 0; for (p = p1; p != p2; p = p->next) { c = p->word[0]; switch (c) { case '(': if (l == 0) { if (lp != 0 && !specp) seterror(ERR_BADPLP); lp = p->next; } l++; goto savep; case ')': l--; if (l == 0) rp = p; goto savep; case '>': if (l != 0) goto savep; if (p->word[1] == '>') t->t_dflg |= F_APPEND; if (p->next != p2 && eq(p->next->word, STRand)) { t->t_dflg |= F_STDERR, p = p->next; if (flags & (POUT | PERR)) { seterror(ERR_OUTRED); continue; } } if (p->next != p2 && eq(p->next->word, STRbang)) t->t_dflg |= F_OVERWRITE, p = p->next; if (p->next == p2) { seterror(ERR_MISRED); continue; } p = p->next; if (any(RELPAR, p->word[0])) { seterror(ERR_MISRED); continue; } if ((flags & POUT) && ((flags & PERR) == 0 || t->t_drit)) seterror(ERR_OUTRED); else t->t_drit = Strsave(p->word); continue; case '<': if (l != 0) goto savep; if (p->word[1] == '<') t->t_dflg |= F_READ; if (p->next == p2) { seterror(ERR_MISRED); continue; } p = p->next; if (any(RELPAR, p->word[0])) { seterror(ERR_MISRED); continue; } if ((flags & PHERE) && (t->t_dflg & F_READ)) seterror(ERR_REDPAR); else if ((flags & PIN) || t->t_dlef) seterror(ERR_INRED); else t->t_dlef = Strsave(p->word); continue; savep: if (!specp) continue; default: if (l != 0 && !specp) continue; if (seterr == 0) av[n] = Strsave(p->word); n++; continue; } } if (lp != 0 && !specp) { if (n != 0) seterror(ERR_BADPLPS); t->t_dtyp = NODE_PAREN; t->t_dspr = syn0(lp, rp, PHERE); } else { if (n == 0) seterror(ERR_NULLCOM); t->t_dtyp = NODE_COMMAND; } return (t); }
/* * Bulk transfer routine -- * used by getfl(), cu_take(), and pipefile() */ static void transfer(char *buf, int fd, char *eofchars) { register int ct; char c; register int cnt, eof, v; time_t start; sig_t f; char r; FILE *ff; v = boolean(value(VERBOSE)); if ((ff = fdopen (fd, "w")) == NULL) { warn("file open"); return; } if ((cnt = number(value(FRAMESIZE))) != BUFSIZ) if (setvbuf(ff, NULL, _IOFBF, cnt) != 0) { warn("file allocation"); (void)fclose(ff); return; } xpwrite(FD, buf, size(buf)); quit = 0; kill(pid, SIGIOT); read(repdes[0], (char *)&ccc, 1); /* Wait until read process stops */ /* * finish command */ r = '\r'; xpwrite(FD, &r, 1); do read(FD, &c, 1); while ((c&0177) != '\n'); usedefchars (); (void) setjmp(intbuf); f = signal(SIGINT, intcopy); start = time(0); for (ct = 0; !quit;) { eof = read(FD, &c, 1) <= 0; c &= 0177; if (quit) continue; if (eof || any(c, eofchars)) break; if (c == 0) continue; /* ignore nulls */ if (c == '\r') continue; if (c == '\n' && v) printf("\r%d", ++ct); fputc(c, ff); } if (v) prtime(" lines transferred in ", time(0)-start); usetchars (); write(fildes[1], (char *)&ccc, 1); signal(SIGINT, f); (void)fclose(ff); }
void BVH4Intersector4Hybrid<types,robust,PrimitiveIntersector4>::intersect(bool4* valid_i, BVH4* bvh, Ray4& ray) { /* verify correct input */ bool4 valid0 = *valid_i; #if defined(RTCORE_IGNORE_INVALID_RAYS) valid0 &= ray.valid(); #endif assert(all(valid0,ray.tnear > -FLT_MIN)); assert(!(types & BVH4::FLAG_NODE_MB) || all(valid0,ray.time >= 0.0f & ray.time <= 1.0f)); /* load ray */ Vec3f4 ray_org = ray.org; Vec3f4 ray_dir = ray.dir; float4 ray_tnear = ray.tnear, ray_tfar = ray.tfar; const Vec3f4 rdir = rcp_safe(ray_dir); const Vec3f4 org(ray_org), org_rdir = org * rdir; ray_tnear = select(valid0,ray_tnear,float4(pos_inf)); ray_tfar = select(valid0,ray_tfar ,float4(neg_inf)); const float4 inf = float4(pos_inf); Precalculations pre(valid0,ray); /* compute near/far per ray */ Vec3i4 nearXYZ; nearXYZ.x = select(rdir.x >= 0.0f,int4(0*(int)sizeof(float4)),int4(1*(int)sizeof(float4))); nearXYZ.y = select(rdir.y >= 0.0f,int4(2*(int)sizeof(float4)),int4(3*(int)sizeof(float4))); nearXYZ.z = select(rdir.z >= 0.0f,int4(4*(int)sizeof(float4)),int4(5*(int)sizeof(float4))); /* allocate stack and push root node */ float4 stack_near[stackSizeChunk]; NodeRef stack_node[stackSizeChunk]; stack_node[0] = BVH4::invalidNode; stack_near[0] = inf; stack_node[1] = bvh->root; stack_near[1] = ray_tnear; NodeRef* stackEnd = stack_node+stackSizeChunk; NodeRef* __restrict__ sptr_node = stack_node + 2; float4* __restrict__ sptr_near = stack_near + 2; while (1) pop: { /* pop next node from stack */ assert(sptr_node > stack_node); sptr_node--; sptr_near--; NodeRef cur = *sptr_node; if (unlikely(cur == BVH4::invalidNode)) { assert(sptr_node == stack_node); break; } /* cull node if behind closest hit point */ float4 curDist = *sptr_near; const bool4 active = curDist < ray_tfar; if (unlikely(none(active))) continue; /* switch to single ray traversal */ #if !defined(__WIN32__) || defined(__X86_64__) size_t bits = movemask(active); if (unlikely(__popcnt(bits) <= SWITCH_THRESHOLD)) { for (size_t i=__bsf(bits); bits!=0; bits=__btc(bits,i), i=__bsf(bits)) { BVH4Intersector4Single<types,robust,PrimitiveIntersector4>::intersect1(bvh, cur, i, pre, ray, ray_org, ray_dir, rdir, ray_tnear, ray_tfar, nearXYZ); } ray_tfar = min(ray_tfar,ray.tfar); continue; } #endif while (1) { /* process normal nodes */ if (likely((types & 0x1) && cur.isNode())) { const bool4 valid_node = ray_tfar > curDist; STAT3(normal.trav_nodes,1,popcnt(valid_node),4); const Node* __restrict__ const node = cur.node(); /* pop of next node */ assert(sptr_node > stack_node); sptr_node--; sptr_near--; cur = *sptr_node; curDist = *sptr_near; #pragma unroll(4) for (unsigned i=0; i<BVH4::N; i++) { const NodeRef child = node->children[i]; if (unlikely(child == BVH4::emptyNode)) break; float4 lnearP; const bool4 lhit = intersect_node<robust>(node,i,org,rdir,org_rdir,ray_tnear,ray_tfar,lnearP); /* if we hit the child we choose to continue with that child if it is closer than the current next child, or we push it onto the stack */ if (likely(any(lhit))) { assert(sptr_node < stackEnd); assert(child != BVH4::emptyNode); const float4 childDist = select(lhit,lnearP,inf); sptr_node++; sptr_near++; /* push cur node onto stack and continue with hit child */ if (any(childDist < curDist)) { *(sptr_node-1) = cur; *(sptr_near-1) = curDist; curDist = childDist; cur = child; } /* push hit child onto stack */ else { *(sptr_node-1) = child; *(sptr_near-1) = childDist; } } } #if SWITCH_DURING_DOWN_TRAVERSAL == 1 // seems to be the best place for testing utilization if (unlikely(popcnt(ray_tfar > curDist) <= SWITCH_THRESHOLD)) { *sptr_node++ = cur; *sptr_near++ = curDist; goto pop; } #endif } /* process motion blur nodes */ else if (likely((types & 0x10) && cur.isNodeMB())) { const bool4 valid_node = ray_tfar > curDist; STAT3(normal.trav_nodes,1,popcnt(valid_node),4); const BVH4::NodeMB* __restrict__ const node = cur.nodeMB(); /* pop of next node */ assert(sptr_node > stack_node); sptr_node--; sptr_near--; cur = *sptr_node; curDist = *sptr_near; #pragma unroll(4) for (unsigned i=0; i<BVH4::N; i++) { const NodeRef child = node->child(i); if (unlikely(child == BVH4::emptyNode)) break; float4 lnearP; const bool4 lhit = intersect_node(node,i,org,rdir,org_rdir,ray_tnear,ray_tfar,ray.time,lnearP); /* if we hit the child we choose to continue with that child if it is closer than the current next child, or we push it onto the stack */ if (likely(any(lhit))) { assert(sptr_node < stackEnd); assert(child != BVH4::emptyNode); const float4 childDist = select(lhit,lnearP,inf); sptr_node++; sptr_near++; /* push cur node onto stack and continue with hit child */ if (any(childDist < curDist)) { *(sptr_node-1) = cur; *(sptr_near-1) = curDist; curDist = childDist; cur = child; } /* push hit child onto stack */ else { *(sptr_node-1) = child; *(sptr_near-1) = childDist; } } } #if SWITCH_DURING_DOWN_TRAVERSAL == 1 // seems to be the best place for testing utilization if (unlikely(popcnt(ray_tfar > curDist) <= SWITCH_THRESHOLD)) { *sptr_node++ = cur; *sptr_near++ = curDist; goto pop; } #endif } else break; }
/* * Main procedure. Process arguments and then * transfer control to the main command processing loop * in the routine commands. We are entered as either "ex", "edit" or "vi" * and the distinction is made here. Actually, we are "vi" if * there is a 'v' in our name, and "edit" if there is a 'd' in our * name. For edit we just diddle options; for vi we actually * force an early visual command, setting the external initev so * the q command in visual doesn't give command mode. */ int main(int ac, char **av) { #ifndef VMUNIX char *erpath = EXSTRINGS; #endif register char *cp; register int c; bool recov = 0; bool ivis; bool itag = 0; bool fast = 0; #ifdef TRACE register char *tracef; #endif /* * Immediately grab the tty modes so that we wont * get messed up if an interrupt comes in quickly. */ gTTY(1); normf = tty; ppid = getpid(); /* * Defend against d's, v's, and a's in directories of * path leading to our true name. */ av[0] = tailpath(av[0]); ivis = any('v', av[0]); /* * For debugging take files out of . if name is a.out. * If a 'd' in our name, then set options for edit. */ #ifndef VMUNIX if (av[0][0] == 'a') erpath = tailpath(erpath); #endif if (ivis) { #ifdef notdef options[BEAUTIFY].odefault = value(BEAUTIFY) = 1; #endif } else if (any('d', av[0])) { value(OPEN) = 0; value(REPORT) = 1; value(MAGIC) = 0; } /* * Open the error message file. */ draino(); #ifndef VMUNIX erfile = open(erpath+4, O_RDONLY); if (erfile < 0) { erfile = open(erpath, O_RDONLY); } #endif pstop(); /* * Initialize interrupt handling. */ oldhup = signal(SIGHUP, SIG_IGN); if (oldhup == SIG_DFL) signal(SIGHUP, onhup); oldquit = signal(SIGQUIT, SIG_IGN); ruptible = signal(SIGINT, SIG_IGN) == SIG_DFL; if (signal(SIGTERM, SIG_IGN) == SIG_DFL) signal(SIGTERM, onhup); /* * Initialize end of core pointers. * Normally we avoid breaking back to fendcore after each * file since this can be expensive (much core-core copying). * If your system can scatter load processes you could do * this as ed does, saving a little core, but it will probably * not often make much difference. */ #ifdef UNIX_SBRK fendcore = (line *) sbrk(0); endcore = fendcore - 2; #else # define LINELIMIT 0x8000 fendcore = malloc(LINELIMIT * sizeof(line *)); endcore = fendcore + LINELIMIT - 1; #endif /* * Process flag arguments. */ ac--, av++; while (ac && av[0][0] == '-') { c = av[0][1]; if (c == 0) { hush = 1; value(AUTOPRINT) = 0; fast++; } else switch (c) { #ifdef TRACE case 'T': if (av[0][2] == 0) tracef = "trace"; else { tracef = tttrace; tracef[8] = av[0][2]; if (tracef[8]) tracef[9] = av[0][3]; else tracef[9] = 0; } trace = fopen(tracef, "w"); if (trace == NULL) ex_printf("Trace create error\n"); setbuf(trace, tracbuf); break; #endif #ifdef LISPCODE case 'l': value(LISP) = 1; value(SHOWMATCH) = 1; break; #endif case 'r': recov++; break; case 't': if (ac > 1 && av[1][0] != '-') { ac--, av++; itag = 1; /* BUG: should check for too long tag. */ CP(lasttag, av[0]); } break; case 'v': ivis = 1; break; case 'w': defwind = 0; if (av[0][2] == 0) defwind = 3; else for (cp = &av[0][2]; isdigit((int)*cp); cp++) defwind = 10*defwind + *cp - '0'; break; default: smerror("Unknown option %s\n", av[0]); break; } ac--, av++; } if (ac && av[0][0] == '+') { firstpat = &av[0][1]; ac--, av++; } /* * If we are doing a recover and no filename * was given, then execute an exrecover command with * the -r option to type out the list of saved file names. * Otherwise set the remembered file name to the first argument * file name so the "recover" initial command will find it. */ if (recov) { if (ac == 0) { ppid = 0; setrupt(); execl(EXRECOVER, "exrecover", "-r", NULL); filioerr(EXRECOVER); exit(1); } CP(savedfile, *av); av++, ac--; } /* * Initialize the argument list. */ argv0 = av; argc0 = ac; args0 = av[0]; erewind(); /* * Initialize a temporary file (buffer) and * set up terminal environment. Read user startup commands. */ init(); if (setexit() == 0) { setrupt(); intty = isatty(0); value(PROMPT) = intty; if (fast || !intty) setterm("dumb"); else { gettmode(); if ((cp = getenv("TERM")) != 0) setterm(cp); } } if (setexit() == 0 && !fast && intty) { if ((globp = getenv("EXINIT"))) commands(1,1); else if ((cp = getenv("HOME")) != 0) source(strcat(strcpy(genbuf, cp), "/.exrc"), 1); } /* * Initial processing. Handle tag, recover, and file argument * implied next commands. If going in as 'vi', then don't do * anything, just set initev so we will do it later (from within * visual). */ if (setexit() == 0) { if (recov) globp = "recover"; else if (itag) globp = ivis ? "tag" : "tag|p"; else if (argc) globp = "next"; if (ivis) initev = globp; else if (globp) { inglobal = 1; commands(1, 1); inglobal = 0; } } /* * Vi command... go into visual. * Strange... everything in vi usually happens * before we ever "start". */ if (ivis) { /* * Don't have to be upward compatible with stupidity * of starting editing at line $. */ if (dol > zero) dot = one; globp = "visual"; if (setexit() == 0) commands(1, 1); } /* * Clear out trash in state accumulated by startup, * and then do the main command loop for a normal edit. * If you quit out of a 'vi' command by doing Q or ^\, * you also fall through to here. */ ungetchar(0); globp = 0; initev = 0; setlastchar('\n'); setexit(); commands(0, 0); cleanup(1); return 0; }
void BVH8iIntersector8Hybrid<TriangleIntersector8>::occluded(avxb* valid_i, BVH8i* bvh, Ray8& ray) { /* load ray */ const avxb valid = *valid_i; avxb terminated = !valid; avx3f ray_org = ray.org, ray_dir = ray.dir; avxf ray_tnear = ray.tnear, ray_tfar = ray.tfar; #if defined(__FIX_RAYS__) const avxf float_range = 0.1f*FLT_MAX; ray_org = clamp(ray_org,avx3f(-float_range),avx3f(+float_range)); ray_dir = clamp(ray_dir,avx3f(-float_range),avx3f(+float_range)); ray_tnear = max(ray_tnear,FLT_MIN); ray_tfar = min(ray_tfar,float(inf)); #endif const avx3f rdir = rcp_safe(ray_dir); const avx3f org(ray_org), org_rdir = org * rdir; ray_tnear = select(valid,ray_tnear,avxf(pos_inf)); ray_tfar = select(valid,ray_tfar ,avxf(neg_inf)); const avxf inf = avxf(pos_inf); /* compute near/far per ray */ avx3i nearXYZ; nearXYZ.x = select(rdir.x >= 0.0f,avxi(0*(int)sizeof(avxf)),avxi(1*(int)sizeof(avxf))); nearXYZ.y = select(rdir.y >= 0.0f,avxi(2*(int)sizeof(avxf)),avxi(3*(int)sizeof(avxf))); nearXYZ.z = select(rdir.z >= 0.0f,avxi(4*(int)sizeof(avxf)),avxi(5*(int)sizeof(avxf))); /* allocate stack and push root node */ avxf stack_near[stackSizeChunk]; NodeRef stack_node[stackSizeChunk]; stack_node[0] = BVH4i::invalidNode; stack_near[0] = inf; stack_node[1] = bvh->root; stack_near[1] = ray_tnear; NodeRef* stackEnd = stack_node+stackSizeChunk; NodeRef* __restrict__ sptr_node = stack_node + 2; avxf* __restrict__ sptr_near = stack_near + 2; const Node * __restrict__ nodes = (Node *)bvh->nodePtr(); const Triangle * __restrict__ accel = (Triangle*)bvh->triPtr(); while (1) { /* pop next node from stack */ assert(sptr_node > stack_node); sptr_node--; sptr_near--; NodeRef curNode = *sptr_node; if (unlikely(curNode == BVH4i::invalidNode)) { assert(sptr_node == stack_node); break; } /* cull node if behind closest hit point */ avxf curDist = *sptr_near; const avxb active = curDist < ray_tfar; if (unlikely(none(active))) continue; /* switch to single ray traversal */ #if !defined(__WIN32__) || defined(__X86_64__) size_t bits = movemask(active); if (unlikely(__popcnt(bits) <= SWITCH_THRESHOLD)) { for (size_t i=__bsf(bits); bits!=0; bits=__btc(bits,i), i=__bsf(bits)) { if (occluded1(bvh,curNode,i,ray,ray_org,ray_dir,rdir,ray_tnear,ray_tfar,nearXYZ)) terminated[i] = -1; } if (all(terminated)) break; ray_tfar = select(terminated,avxf(neg_inf),ray_tfar); continue; } #endif while (1) { /* test if this is a leaf node */ if (unlikely(curNode.isLeaf())) break; const avxb valid_node = ray_tfar > curDist; STAT3(shadow.trav_nodes,1,popcnt(valid_node),8); const Node* __restrict__ const node = (Node*)curNode.node(nodes); /* pop of next node */ assert(sptr_node > stack_node); sptr_node--; sptr_near--; curNode = *sptr_node; curDist = *sptr_near; for (unsigned i=0; i<8; i++) { const NodeRef child = node->children[i]; if (unlikely(child == BVH4i::emptyNode)) break; #if defined(__AVX2__) const avxf lclipMinX = msub(node->lower_x[i],rdir.x,org_rdir.x); const avxf lclipMinY = msub(node->lower_y[i],rdir.y,org_rdir.y); const avxf lclipMinZ = msub(node->lower_z[i],rdir.z,org_rdir.z); const avxf lclipMaxX = msub(node->upper_x[i],rdir.x,org_rdir.x); const avxf lclipMaxY = msub(node->upper_y[i],rdir.y,org_rdir.y); const avxf lclipMaxZ = msub(node->upper_z[i],rdir.z,org_rdir.z); const avxf lnearP = maxi(maxi(mini(lclipMinX, lclipMaxX), mini(lclipMinY, lclipMaxY)), mini(lclipMinZ, lclipMaxZ)); const avxf lfarP = mini(mini(maxi(lclipMinX, lclipMaxX), maxi(lclipMinY, lclipMaxY)), maxi(lclipMinZ, lclipMaxZ)); const avxb lhit = maxi(lnearP,ray_tnear) <= mini(lfarP,ray_tfar); #else const avxf lclipMinX = (node->lower_x[i] - org.x) * rdir.x; const avxf lclipMinY = (node->lower_y[i] - org.y) * rdir.y; const avxf lclipMinZ = (node->lower_z[i] - org.z) * rdir.z; const avxf lclipMaxX = (node->upper_x[i] - org.x) * rdir.x; const avxf lclipMaxY = (node->upper_y[i] - org.y) * rdir.y; const avxf lclipMaxZ = (node->upper_z[i] - org.z) * rdir.z; const avxf lnearP = max(max(min(lclipMinX, lclipMaxX), min(lclipMinY, lclipMaxY)), min(lclipMinZ, lclipMaxZ)); const avxf lfarP = min(min(max(lclipMinX, lclipMaxX), max(lclipMinY, lclipMaxY)), max(lclipMinZ, lclipMaxZ)); const avxb lhit = max(lnearP,ray_tnear) <= min(lfarP,ray_tfar); #endif /* if we hit the child we choose to continue with that child if it is closer than the current next child, or we push it onto the stack */ if (likely(any(lhit))) { assert(sptr_node < stackEnd); assert(child != BVH4i::emptyNode); const avxf childDist = select(lhit,lnearP,inf); sptr_node++; sptr_near++; /* push cur node onto stack and continue with hit child */ if (any(childDist < curDist)) { *(sptr_node-1) = curNode; *(sptr_near-1) = curDist; curDist = childDist; curNode = child; } /* push hit child onto stack */ else { *(sptr_node-1) = child; *(sptr_near-1) = childDist; } } } } /* return if stack is empty */ if (unlikely(curNode == BVH4i::invalidNode)) { assert(sptr_node == stack_node); break; } /* intersect leaf */ const avxb valid_leaf = ray_tfar > curDist; STAT3(shadow.trav_leaves,1,popcnt(valid_leaf),8); size_t items; const Triangle* prim = (Triangle*) curNode.leaf(accel,items); terminated |= TriangleIntersector8::occluded(!terminated,ray,prim,items,bvh->geometry); if (all(terminated)) break; ray_tfar = select(terminated,avxf(neg_inf),ray_tfar); } store8i(valid & terminated,&ray.geomID,0); AVX_ZERO_UPPER(); }
int main() { char s1[] = "hello world"; char s2[] = "pjwyh"; printf("%d\n", any(s1,s2)); return 0; }
/* * ****TIPOUT TIPOUT**** */ void tipout(void) { char buf[BUFSIZ]; char *cp; ssize_t scnt; size_t cnt; sigset_t mask, omask; signal(SIGINT, SIG_IGN); signal(SIGQUIT, SIG_IGN); signal(SIGEMT, intEMT); /* attention from TIPIN */ signal(SIGTERM, intTERM); /* time to go signal */ signal(SIGIOT, intIOT); /* scripting going on signal */ signal(SIGHUP, intTERM); /* for dial-ups */ signal(SIGSYS, intSYS); /* beautify toggle */ (void) setjmp(sigbuf); sigprocmask(SIG_BLOCK, NULL, &omask); for (;;) { sigprocmask(SIG_SETMASK, &omask, NULL); scnt = read(FD, buf, BUFSIZ); if (scnt <= 0) { /* lost carrier */ if (scnt == 0 || (scnt < 0 && (errno == EIO || errno == ENXIO))) { sigemptyset(&mask); sigaddset(&mask, SIGTERM); sigprocmask(SIG_BLOCK, &mask, NULL); intTERM(SIGHUP); /*NOTREACHED*/ } continue; } cnt = scnt; sigemptyset(&mask); sigaddset(&mask, SIGEMT); sigaddset(&mask, SIGTERM); sigaddset(&mask, SIGIOT); sigaddset(&mask, SIGSYS); sigprocmask(SIG_BLOCK, &mask, NULL); for (cp = buf; cp < buf + cnt; cp++) *cp &= STRIP_PAR; write(STDOUT_FILENO, buf, cnt); if (boolean(value(SCRIPT)) && fscript != NULL) { if (!boolean(value(BEAUTIFY))) { fwrite(buf, 1, cnt, fscript); } else { for (cp = buf; cp < buf + cnt; cp++) if ((*cp >= ' ' && *cp <= '~') || any(*cp, value(EXCEPTIONS))) putc(*cp, fscript); } for (cp = buf; cp < buf + cnt; cp++) { if (!isgraph(*cp)) { fflush(fscript); break; } } } } }
void BVH4iIntersector4Chunk<TriangleIntersector4>::intersect(sseb* valid_i, BVH4i* bvh, Ray4& ray) { /* load node and primitive array */ const Node * __restrict__ nodes = (Node *)bvh->nodePtr(); const Triangle * __restrict__ accel = (Triangle*)bvh->triPtr(); /* load ray */ const sseb valid0 = *valid_i; const sse3f rdir = rcp_safe(ray.dir); const sse3f org_rdir = ray.org * rdir; ssef ray_tnear = select(valid0,ray.tnear,pos_inf); ssef ray_tfar = select(valid0,ray.tfar ,neg_inf); const ssef inf = ssef(pos_inf); /* allocate stack and push root node */ ssef stack_near[3*BVH4i::maxDepth+1]; NodeRef stack_node[3*BVH4i::maxDepth+1]; stack_node[0] = BVH4i::invalidNode; stack_near[0] = inf; stack_node[1] = bvh->root; stack_near[1] = ray_tnear; NodeRef* __restrict__ sptr_node = stack_node + 2; ssef* __restrict__ sptr_near = stack_near + 2; while (1) { /* pop next node from stack */ sptr_node--; sptr_near--; NodeRef curNode = *sptr_node; if (unlikely(curNode == BVH4i::invalidNode)) break; /* cull node if behind closest hit point */ ssef curDist = *sptr_near; if (unlikely(none(ray_tfar > curDist))) continue; while (1) { /* test if this is a leaf node */ if (unlikely(curNode.isLeaf())) break; const sseb valid_node = ray_tfar > curDist; STAT3(normal.trav_nodes,1,popcnt(valid_node),4); const Node* __restrict__ const node = curNode.node(nodes); /* pop of next node */ sptr_node--; sptr_near--; curNode = *sptr_node; // FIXME: this trick creates issues with stack depth curDist = *sptr_near; #pragma unroll(4) for (unsigned i=0; i<4; i++) { const NodeRef child = node->children[i]; if (unlikely(child == BVH4i::emptyNode)) break; #if defined(__AVX2__) const ssef lclipMinX = msub(node->lower_x[i],rdir.x,org_rdir.x); const ssef lclipMinY = msub(node->lower_y[i],rdir.y,org_rdir.y); const ssef lclipMinZ = msub(node->lower_z[i],rdir.z,org_rdir.z); const ssef lclipMaxX = msub(node->upper_x[i],rdir.x,org_rdir.x); const ssef lclipMaxY = msub(node->upper_y[i],rdir.y,org_rdir.y); const ssef lclipMaxZ = msub(node->upper_z[i],rdir.z,org_rdir.z); const ssef lnearP = maxi(maxi(mini(lclipMinX, lclipMaxX), mini(lclipMinY, lclipMaxY)), mini(lclipMinZ, lclipMaxZ)); const ssef lfarP = mini(mini(maxi(lclipMinX, lclipMaxX), maxi(lclipMinY, lclipMaxY)), maxi(lclipMinZ, lclipMaxZ)); const sseb lhit = maxi(lnearP,ray_tnear) <= mini(lfarP,ray_tfar); #else const ssef lclipMinX = node->lower_x[i] * rdir.x - org_rdir.x; const ssef lclipMinY = node->lower_y[i] * rdir.y - org_rdir.y; const ssef lclipMinZ = node->lower_z[i] * rdir.z - org_rdir.z; const ssef lclipMaxX = node->upper_x[i] * rdir.x - org_rdir.x; const ssef lclipMaxY = node->upper_y[i] * rdir.y - org_rdir.y; const ssef lclipMaxZ = node->upper_z[i] * rdir.z - org_rdir.z; const ssef lnearP = max(max(min(lclipMinX, lclipMaxX), min(lclipMinY, lclipMaxY)), min(lclipMinZ, lclipMaxZ)); const ssef lfarP = min(min(max(lclipMinX, lclipMaxX), max(lclipMinY, lclipMaxY)), max(lclipMinZ, lclipMaxZ)); const sseb lhit = max(lnearP,ray_tnear) <= min(lfarP,ray_tfar); #endif /* if we hit the child we choose to continue with that child if it is closer than the current next child, or we push it onto the stack */ if (likely(any(lhit))) { const ssef childDist = select(lhit,lnearP,inf); sptr_node++; sptr_near++; /* push cur node onto stack and continue with hit child */ if (any(childDist < curDist)) { *(sptr_node-1) = curNode; *(sptr_near-1) = curDist; curDist = childDist; curNode = child; } /* push hit child onto stack */ else { *(sptr_node-1) = child; *(sptr_near-1) = childDist; } assert(sptr_node - stack_node < BVH4i::maxDepth); } } } /* return if stack is empty */ if (unlikely(curNode == BVH4i::invalidNode)) break; /* intersect leaf */ const sseb valid_leaf = ray_tfar > curDist; STAT3(normal.trav_leaves,1,popcnt(valid_leaf),4); size_t items; const Triangle* tri = (Triangle*) curNode.leaf(accel, items); TriangleIntersector4::intersect(valid_leaf,ray,tri,items,bvh->geometry); ray_tfar = select(valid_leaf,ray.tfar,ray_tfar); } AVX_ZERO_UPPER(); }
/** Converts the Rect2D to an Any. */ Rect2D::operator Any() const { Any any(Any::ARRAY, "Rect2D::xywh"); any.append(x0(), y0(), width(), height()); return any; }
Vector4::operator Any() const { Any any(Any::ARRAY, "Vector4"); any.append(x, y, z, w); return any; }
void BVH2Intersector8Chunk<TriangleIntersector>::intersect(const BVH2Intersector8Chunk* This, Ray8& ray, const __m256 valid_i) { avxb valid = valid_i; const BVH2* bvh = This->bvh; STAT3(normal.travs,1,popcnt(valid),8); struct StackItem { NodeRef ptr; avxf dist; }; StackItem stack[1+BVH2::maxDepth]; //!< stack of nodes that still need to get traversed StackItem* stackPtr = stack; //!< current stack pointer NodeRef cur = bvh->root; //!< in cur we track the ID of the current node /* let inactive rays miss all boxes */ const avx3f rdir = rcp_safe(ray.dir); ray.tfar = select(valid,ray.tfar,avxf(neg_inf)); while (true) { /*! downtraversal loop */ while (likely(cur.isNode())) { STAT3(normal.trav_nodes,1,popcnt(valid),8); /* intersect packet with box of both children */ const Node* node = cur.node(); avxf dist0; size_t hit0 = intersectBox(ray.org,rdir,ray.tnear,ray.tfar,node,0,dist0); avxf dist1; size_t hit1 = intersectBox(ray.org,rdir,ray.tnear,ray.tfar,node,1,dist1); /*! if two children hit, push far node onto stack and continue with closer node */ if (likely(hit0 != 0 && hit1 != 0)) { if (any(valid & (dist0 < dist1))) { stackPtr->ptr = node->child(1); stackPtr->dist = dist1; stackPtr++; cur = node->child(0); } else { stackPtr->ptr = node->child(0); stackPtr->dist = dist0; stackPtr++; cur = node->child(1); } } /*! if one child hit, continue with that child */ else { if (likely(hit0 != 0)) cur = node->child(0); else if (likely(hit1 != 0)) cur = node->child(1); else goto pop_node; } } /*! leaf node, intersect all triangles */ { STAT3(normal.trav_leaves,1,popcnt(valid),8); size_t num; Triangle* tri = (Triangle*) cur.leaf(NULL,num); for (size_t i=0; i<num; i++) { TriangleIntersector::intersect(valid,ray,tri[i],bvh->vertices); } } /*! pop next node from stack */ pop_node: if (unlikely(stackPtr == stack)) break; --stackPtr; cur = stackPtr->ptr; if (unlikely(all(stackPtr->dist > ray.tfar))) goto pop_node; } }
int main(void) { char *leftstr[] = { "", "a", "antidisestablishmentarianism", "beautifications", "characteristically", "deterministically", "electroencephalography", "familiarisation", "gastrointestinal", "heterogeneousness", "incomprehensibility", "justifications", "knowledgeable", "lexicographically", "microarchitectures", "nondeterministically", "organizationally", "phenomenologically", "quantifications", "representationally", "straightforwardness", "telecommunications", "uncontrollability", "vulnerabilities", "wholeheartedly", "xylophonically", "youthfulness", "zoologically" }; char *rightstr[] = { "", "a", "the", "quick", "brown", "dog", "jumps", "over", "lazy", "fox", "get", "rid", "of", "windows", "and", "install", "linux" }; size_t numlefts = sizeof leftstr / sizeof leftstr[0]; size_t numrights = sizeof rightstr / sizeof rightstr[0]; size_t left = 0; size_t right = 0; int passed = 0; int failed = 0; int pos = -1; char *ptr = NULL; for (left = 0; left < numlefts; left++) { for (right = 0; right < numrights; right++) { pos = any(leftstr[left], rightstr[right]); ptr = strpbrk(leftstr[left], rightstr[right]); if (-1 == pos) { if (ptr != NULL) { printf("Test %d/%d failed.\n", left, right); ++failed; } else { printf("Test %d/%d passed.\n", left, right); ++passed; } } else { if(ptr == NULL) { printf("Test %d/%d failed.\n", left, right); ++failed; } else { if(ptr - leftstr[left] == pos) { printf("Test %d/%d passed.\n", left, right); ++passed; } else { printf("Test %d/%d failed.\n", left, right); ++failed; } } } } } printf("\n\nTotal passes %d, fails %d, total tests %d\n", passed, failed, passed + failed); return 0; }
void intersect_same_types (basic_string_token &rhs_, basic_string_token &overlap_) { if (any ()) { clear (); overlap_._negated = true; rhs_.clear (); } else { typename string::iterator iter_ = _chars.begin (); typename string::iterator end_ = _chars.end (); typename string::iterator rhs_iter_ = rhs_._chars.begin (); typename string::iterator rhs_end_ = rhs_._chars.end (); overlap_._negated = _negated; while (iter_ != end_ && rhs_iter_ != rhs_end_) { if (*iter_ < *rhs_iter_) { ++iter_; } else if (*iter_ > *rhs_iter_) { ++rhs_iter_; } else { overlap_._chars += *iter_; iter_ = _chars.erase (iter_); end_ = _chars.end (); rhs_iter_ = rhs_._chars.erase (rhs_iter_); rhs_end_ = rhs_._chars.end (); } } if (_negated) { // duplicates already merged, so safe to merge // using std lib. // src, dest merge (_chars, overlap_._chars); // duplicates already merged, so safe to merge // using std lib. // src, dest merge (rhs_._chars, overlap_._chars); _negated = false; rhs_._negated = false; std::swap (_chars, rhs_._chars); normalise (); overlap_.normalise (); rhs_.normalise (); } else if (!overlap_._chars.empty ()) { normalise (); overlap_.normalise (); rhs_.normalise (); } } }
size_t formatted_write(T x, charT *buf, size_t buf_len) const { return details::render(x, details::int_render_helper<T,10>(x), any(showpos), buf, buf_len); }
void BVH4Intersector4Chunk<TriangleIntersector4>::intersect(const BVH4Intersector4Chunk* This, Ray4& ray, const __m128 valid_i) { sseb valid = valid_i; NodeRef invalid = (NodeRef)1; const BVH4* bvh = This->bvh; STAT3(normal.travs,1,popcnt(valid),4); /* load ray into registers */ ssef ray_near = select(valid,ray.tnear,pos_inf); ssef ray_far = select(valid,ray.tfar ,neg_inf); sse3f rdir = rcp_safe(ray.dir); ray.tfar = ray_far; /* allocate stack and push root node */ NodeRef stack_node[3*BVH4::maxDepth+1]; ssef stack_near[3*BVH4::maxDepth+1]; stack_node[0] = invalid; stack_near[0] = ssef(inf); stack_node[1] = bvh->root; stack_near[1] = ray_near; NodeRef* sptr_node = stack_node+2; ssef * sptr_near = stack_near+2; while (1) { /* pop next node from stack */ sptr_node--; sptr_near--; ssef curDist = *sptr_near; NodeRef curNode = *sptr_node; if (unlikely(curNode == invalid)) break; /* cull node if behind closest hit point */ const sseb m_dist = curDist < ray_far; if (unlikely(none(m_dist))) continue; while (1) { /* test if this is a leaf node */ if (unlikely(curNode.isLeaf())) break; STAT3(normal.trav_nodes,1,popcnt(valid),4); const Node* const node = curNode.node(bvh->nodePtr()); //NodeRef(curNode).node(nodes); //prefetch<PFHINT_L1>((ssef*)node + 1); // depth first order prefetch /* pop of next node */ sptr_node--; sptr_near--; curNode = *sptr_node; curDist = *sptr_near; for (unsigned i=0;i<4;i++) { const ssef dminx = (ssef(node->lower_x[i]) - ray.org.x) * rdir.x; const ssef dmaxx = (ssef(node->upper_x[i]) - ray.org.x) * rdir.x; const ssef dminy = (ssef(node->lower_y[i]) - ray.org.y) * rdir.y; const ssef dmaxy = (ssef(node->upper_y[i]) - ray.org.y) * rdir.y; const ssef dminz = (ssef(node->lower_z[i]) - ray.org.z) * rdir.z; const ssef dmaxz = (ssef(node->upper_z[i]) - ray.org.z) * rdir.z; const ssef dlowerx = min(dminx,dmaxx); const ssef dupperx = max(dminx,dmaxx); const ssef dlowery = min(dminy,dmaxy); const ssef duppery = max(dminy,dmaxy); const ssef dlowerz = min(dminz,dmaxz); const ssef dupperz = max(dminz,dmaxz); const ssef near = max(dlowerx,dlowery,dlowerz,ray_near); const ssef far = min(dupperx,duppery,dupperz,ray_far ); const sseb mhit = near <= far; const ssef childDist = select(mhit,near,inf); const sseb closer = childDist < curDist; /* if we hit the child we choose to continue with that child if it is closer than the current next child, or we push it onto the stack */ if (likely(any(mhit))) { const NodeRef child = node->child(i); //if (child != invalid) { sptr_node++; sptr_near++; /* push cur node onto stack and continue with hit child */ if (any(closer)) { *(sptr_node-1) = curNode; *(sptr_near-1) = curDist; curDist = childDist; curNode = child; } /* push hit child onto stack*/ else { *(sptr_node-1) = child; *(sptr_near-1) = childDist; } } } } } /* return if stack is empty */ if (unlikely(curNode == invalid)) break; /* decode leaf node */ size_t num; STAT3(normal.trav_leaves,1,popcnt(valid),4); Triangle* tri = (Triangle*) curNode.leaf(bvh->triPtr(),num); /* intersect triangles */ for (size_t i=0; i<num; i++) TriangleIntersector4::intersect(valid,ray,tri[i],bvh->vertices); ray_far = ray.tfar; } }