static void remap34(int8_t (**p_par_mapped)[PS_MAX_NR_IIDICC], int8_t (*par)[PS_MAX_NR_IIDICC], int num_par, int num_env, int full) { int8_t (*par_mapped)[PS_MAX_NR_IIDICC] = *p_par_mapped; int e; if (num_par == 20 || num_par == 11) { for (e = 0; e < num_env; e++) { map_idx_20_to_34(par_mapped[e], par[e], full); } } else if (num_par == 10 || num_par == 5) { for (e = 0; e < num_env; e++) { map_idx_10_to_34(par_mapped[e], par[e], full); } } else { *p_par_mapped = par; } }
void VMMemory::setScalar(RXEFile::dstocType type, void *memoryLocation, int32_t value) throw(std::invalid_argument) { switch (type) { // Default case RXEFile::TC_UBYTE: reinterpret_cast<uint8_t *>(memoryLocation)[0] = SwapHostToLittle(uint8_t(value)); break; case RXEFile::TC_SBYTE: reinterpret_cast<int8_t *>(memoryLocation)[0] = SwapHostToLittle(int8_t(value)); break; case RXEFile::TC_UWORD: reinterpret_cast<uint16_t *>(memoryLocation)[0] = SwapHostToLittle(uint16_t(value)); break; case RXEFile::TC_SWORD: reinterpret_cast<int16_t *>(memoryLocation)[0] = SwapHostToLittle(int16_t(value)); break; case RXEFile::TC_ULONG: reinterpret_cast<uint32_t *>(memoryLocation)[0] = SwapHostToLittle(uint32_t(value)); break; case RXEFile::TC_SLONG: reinterpret_cast<int32_t *>(memoryLocation)[0] = SwapHostToLittle(int32_t(value)); break; // Special cases // A mutex is a 32-bit value, containing whatever the system puts in there. case RXEFile::TC_MUTEX: reinterpret_cast<uint32_t *>(memoryLocation)[0] = SwapHostToLittle(uint32_t(value)); break; // Extremely sketchy support for floats. case RXEFile::TC_FLOAT: reinterpret_cast<float *>(memoryLocation)[0] = SwapHostToLittle(float(value)); break; // We do NOT like clusters and voids. We also do not allow writing to // the dstoc entry for an array. That just causes all sorts of // trouble. default: throw std::invalid_argument("Invalid DSTOC type used for get"); } }
void main() { struct WORDREGS { unsigned int ax,bx,cx,dx,si,di,cflag,flags; }; struct BYTEREGS { unsigned char al,ah,bl,bh,cl,ch,dl,dh; }; union REGS { struct WORDREGS x; struct BYTEREGS h; }; union REGS inregs,outregs; int memsize; int8_t(18,&inregs,&outregs); memsize=outregs.x.ax; printf("\ntotal memory size =%d",memsize); }
int main( int, char** ) { std::list< lunchbox::Any > testValues; testValues.push_back( int8_t( -1 )); testValues.push_back( uint8_t( 1 )); testValues.push_back( int16_t( -10 )); testValues.push_back( uint16_t( 10 )); testValues.push_back( int32_t( -100 )); testValues.push_back( uint32_t( 100 )); testValues.push_back( int64_t( -1000 )); testValues.push_back( uint64_t( 1000 )); testValues.push_back( bool( false )); testValues.push_back( float( 5.42f )); testValues.push_back( double( 17.56789 )); testValues.push_back( std::string( "blablub" )); testValues.push_back( servus::uint128_t( servus::make_uint128( "bla"))); Foo foo = {42, 1.5f, false, "blablub"}; testValues.push_back( foo ); BOOST_FOREACH( const lunchbox::Any& any, testValues ) { textSerializeAndTest( any ); binarySerializeAndTest( any ); }
int utTypes(){ // Array { // test the basic C functionality const int comps = 1; // const int dims = 2; // no. dimensions const int size0 = 2; // no. elements in dimension 1 const int size1 = 64; // no. elements in dimension 2 const int stride0 = comps * sizeof(data_t); // byte offset at dim 0 const int stride1 = stride0*size0; data_t data[comps*size0*size1]; AlloArrayHeader hdr; hdr.type = AlloFloat64Ty; hdr.components = comps; hdr.dimcount = dims; hdr.dim[0] = size0; hdr.dim[1] = size1; hdr.stride[0] = stride0; hdr.stride[1] = stride1; AlloArray lat; lat.data.ptr = (char *)&data; allo_array_setheader(&lat, &hdr); assert(allo_array_elements(&lat) == size0*size1); assert(allo_array_size(&lat) == sizeof(data)); } { AlloArrayHeader hdr; hdr.type = AlloSInt8Ty; hdr.components = 1; hdr.dim[0] = 7; hdr.dim[1] = 7; // 2D test hdr.dimcount = 2; allo_array_setstride(&hdr, 1); assert(hdr.stride[0] == 1); assert(hdr.stride[1] == 7); allo_array_setstride(&hdr, 4); assert(hdr.stride[1] == 8); allo_array_setstride(&hdr, 8); assert(hdr.stride[1] == 8); // 3D test hdr.dimcount = 3; allo_array_setstride(&hdr, 4); assert(hdr.stride[2] == 8*7); } { // Basic Array usage // TODO: move this to an example // // a 1D array of float-pairs (e.g. interleaved audio buffer) // Array buf(2, AlloFloat32Ty, 64); // // // a 2D array of char[4] data (e.g. ARGB image matrix with color values as 0-255) // Array img(4, AlloUInt8Ty, 720, 480); // // // a 3D array of float triplets (e.g. vector field) // Array field(3, Array::type<float>(), 16, 16, 16); { Array a; assert(a.size() == 0); assert(!a.hasData()); assert(a.type() == AlloVoidTy); assert(a.isType(AlloVoidTy)); assert(a.isFormat(a)); } // Run tests on Arrays with various sizes and dimensions const int Nc= 3; const int Ns[] = {1, 4, 5, 6, 7, 64, 128, 129}; for(unsigned iN=0; iN<sizeof(Ns)/sizeof(*Ns); ++iN){ int N = Ns[iN]; // number of cells along each dimension { // Constructors { Array a(Nc, AlloFloat32Ty, N); assert(a.hasData()); assert(a.type() == AlloFloat32Ty); assert(a.components() == Nc); assert(a.dimcount() == 1); } { Array a(Nc, AlloFloat32Ty, N,N); assert(a.hasData()); assert(a.type() == AlloFloat32Ty); assert(a.components() == Nc); assert(a.dimcount() == 2); } { Array a(Nc, AlloFloat32Ty, N,N,N); assert(a.hasData()); assert(a.type() == AlloFloat32Ty); assert(a.components() == Nc); assert(a.dimcount() == 3); } } { // Memory allocation Array a; a.formatAligned(Nc, AlloFloat32Ty, N, 1); assert((int)a.size() == Nc*N*4); assert(a.hasData()); assert(a.isType(AlloFloat32Ty)); assert(a.isType<float>()); a.formatAligned(Nc, AlloSInt8Ty, N, N, 1); assert((int)a.size() == Nc*N*N*1); assert(a.hasData()); assert(a.isType(AlloSInt8Ty)); assert(a.isType<int8_t>()); a.formatAligned(Nc, AlloSInt16Ty, N, N, N, 1); assert((int)a.size() == Nc*N*N*N*2); assert(a.hasData()); assert(a.isType(AlloSInt16Ty)); assert(a.isType<int16_t>()); } { // 1-D element access Array a(Nc, AlloSInt8Ty, N); for(int i=0,t=0; i<N; ++i){ int8_t x[Nc] = {int8_t(i), int8_t(i+1), int8_t(i+2)}; int8_t y[Nc] = {-1,-1,-1}; a.write(x, i); a.read(y, i); for(int c=0; c<Nc; ++c) assert(y[c] == x[c]); for(int c=0; c<Nc; ++c){ a.elem<int8_t>(c,i) = t+1; assert(a.elem<int8_t>(c,i) == int8_t(t+1)); ++t; } } } { // 2-D element access Array a(Nc, AlloSInt8Ty, N,N); for(int j=0,t=0; j<N; ++j){ for(int i=0; i<N; ++i){ int8_t x[Nc] = {int8_t(j), int8_t(j+1), int8_t(j+2)}; int8_t y[Nc] = {-1,-1,-1}; a.write(x, i,j); a.read(y, i,j); for(int c=0; c<Nc; ++c) assert(y[c] == x[c]); for(int c=0; c<Nc; ++c){ a.elem<int8_t>(c,i,j) = t+1; assert(a.elem<int8_t>(c,i,j) == int8_t(t+1)); ++t; } }} } { // 3-D element access Array a(Nc, AlloSInt8Ty, N,N,N); for(int k=0,t=0; k<N; ++k){ for(int j=0; j<N; ++j){ for(int i=0; i<N; ++i){ int8_t x[Nc] = {int8_t(k), int8_t(k+1), int8_t(k+2)}; int8_t y[Nc] = {-1,-1,-1}; a.write(x, i,j,k); a.read(y, i,j,k); for(int c=0; c<Nc; ++c) assert(y[c] == x[c]); for(int c=0; c<Nc; ++c){ a.elem<int8_t>(c,i,j,k) = t+1; assert(a.elem<int8_t>(c,i,j,k) == int8_t(t+1)); ++t; } }}} } } // end size loop } { Buffer<int> a(0,2); assert(a.size() == 0); assert(a.capacity() == 2); //assert(a.fill() == 0); a.append(1); assert(a[0] == 1); assert(a.size() == 1); assert(a.last() == 1); a.append(2); a.append(3); assert(a.size() == 3); assert(a.capacity() == 4); assert(a.last() == 3); a.reset(); assert(a.size() == 0); assert(a.capacity() == 4); a.append(7); a.repeatLast(); assert(a[0] == 7); assert(a[1] == 7); // Appending another Buffer { Buffer<int> b(4); for(int i=0; i<b.size(); ++i) b[i] = i+4; a.size(4); for(int i=0; i<a.size(); ++i) a[i] = i; // Append non-zero sized to non-zero sized { int N = a.size() + b.size(); a.append(b); assert(a.size() == N); for(int i=0; i<N; ++i) assert(a[i] == i); } // Append non-zero sized to zero sized a.size(0); a.append(b); assert(a.size() == b.size()); for(int i=0; i<a.size(); ++i) assert(a[i] == b[i]); // Append zero sized to non-zero sized { int N = a.size(); b.size(0); a.append(b); assert(a.size() == N); } } } { RingBuffer<int> a; // Test ring buffering a.resize(4); assert(a.size() == 4); a.write(1); a.write(2); //assert(a.fill() == 2); a.write(3); a.write(4); assert(a.pos() == 3); assert(a[0] == 1); assert(a[1] == 2); assert(a[2] == 3); assert(a[3] == 4); assert(a.read(0) == 4); assert(a.read(1) == 3); assert(a.read(2) == 2); assert(a.read(3) == 1); //assert(a.fill() == 4); a.write(5); //assert(a.fill() == 4); assert(a[0] == 5); assert(a.read(0) == 5); assert(a.read(1) == 4); assert(a.read(2) == 3); assert(a.read(3) == 2); } return 0; }
TEST(getSwitch, DISABLED_VfasWithDelay) { MODEL_RESET(); MIXER_RESET(); memclear(&frskyData, sizeof(frskyData)); /* Test for logical switch: L1 Vfas < 9.6 Delay (0.5s) (gdb) print Open9xX9D::g_model.logicalSw[0] $3 = {v1 = -39 '\331', v2 = 96, v3 = 0, func = 4 '\004', delay = 5 '\005', duration = 0 '\000', andsw = 0 '\000'} */ g_model.logicalSw[0] = {int8_t(MIXSRC_FIRST_TELEM+TELEM_VFAS-1), 96, 0, 4, 5, 0, 0}; frskyData.hub.vfas = 150; //unit is 100mV //telemetry streaming is FALSE, so L1 should be FALSE no matter what value Vfas has evalLogicalSwitches(); EXPECT_EQ(getSwitch(SWSRC_SW1), false); logicalSwitchesTimerTick(); evalLogicalSwitches(); EXPECT_EQ(getSwitch(SWSRC_SW1), false); logicalSwitchesTimerTick(); evalLogicalSwitches(); EXPECT_EQ(getSwitch(SWSRC_SW1), false); logicalSwitchesTimerTick(); evalLogicalSwitches(); EXPECT_EQ(getSwitch(SWSRC_SW1), false); logicalSwitchesTimerTick(); evalLogicalSwitches(); EXPECT_EQ(getSwitch(SWSRC_SW1), false); //every logicalSwitchesTimerTick() represents 100ms //so now after 5 ticks we should still have a FALSE value logicalSwitchesTimerTick(); evalLogicalSwitches(); EXPECT_EQ(getSwitch(SWSRC_SW1), false); //now turn on telemetry EXPECT_EQ(TELEMETRY_STREAMING(), false); TELEMETRY_RSSI() = 50; EXPECT_EQ(TELEMETRY_STREAMING(), true); //vfas is 15.0V so L1 should still be FALSE logicalSwitchesTimerTick(); evalLogicalSwitches(); EXPECT_EQ(getSwitch(SWSRC_SW1), false); logicalSwitchesTimerTick(); logicalSwitchesTimerTick(); logicalSwitchesTimerTick(); logicalSwitchesTimerTick(); logicalSwitchesTimerTick(); evalLogicalSwitches(); EXPECT_EQ(getSwitch(SWSRC_SW1), false); //now reduce vfas to 9.5V and L1 should become TRUE after 0.5s frskyData.hub.vfas = 95; evalLogicalSwitches(); logicalSwitchesTimerTick(); evalLogicalSwitches(); EXPECT_EQ(getSwitch(SWSRC_SW1), false); logicalSwitchesTimerTick(); evalLogicalSwitches(); EXPECT_EQ(getSwitch(SWSRC_SW1), false); logicalSwitchesTimerTick(); evalLogicalSwitches(); EXPECT_EQ(getSwitch(SWSRC_SW1), false); logicalSwitchesTimerTick(); evalLogicalSwitches(); EXPECT_EQ(getSwitch(SWSRC_SW1), false); logicalSwitchesTimerTick(); evalLogicalSwitches(); EXPECT_EQ(getSwitch(SWSRC_SW1), true); logicalSwitchesTimerTick(); logicalSwitchesTimerTick(); logicalSwitchesTimerTick(); logicalSwitchesTimerTick(); evalLogicalSwitches(); EXPECT_EQ(getSwitch(SWSRC_SW1), true); //now stop telemetry, L1 should become FALSE immediatelly TELEMETRY_RSSI() = 0; EXPECT_EQ(TELEMETRY_STREAMING(), false); evalLogicalSwitches(); logicalSwitchesTimerTick(); logicalSwitchesTimerTick(); logicalSwitchesTimerTick(); logicalSwitchesTimerTick(); logicalSwitchesTimerTick(); evalLogicalSwitches(); EXPECT_EQ(getSwitch(SWSRC_SW1), false); }
TEST(getSwitch, DISABLED_RssiWithDuration) { MODEL_RESET(); MIXER_RESET(); memclear(&frskyData, sizeof(frskyData)); /* Test for logical switch: L1 RSSI > 10 Duration (0.5s) (gdb) print Open9xX9D::g_model.logicalSw[0] $1 = {v1 = -55 '\311', v2 = 10, v3 = 0, func = 3 '\003', delay = 0 '\000', duration = 5 '\005', andsw = 0 '\000'} */ g_model.logicalSw[0] = {int8_t(MIXSRC_FIRST_TELEM+TELEM_RSSI_RX-1), 10, 0, 3, 0, 5, 0}; EXPECT_EQ(TELEMETRY_STREAMING(), false); evalLogicalSwitches(); logicalSwitchesTimerTick(); evalLogicalSwitches(); EXPECT_EQ(getSwitch(SWSRC_SW1), false); logicalSwitchesTimerTick(); evalLogicalSwitches(); EXPECT_EQ(getSwitch(SWSRC_SW1), false); //now set RSSI to 5, L1 should still be FALSE TELEMETRY_RSSI() = 5; evalLogicalSwitches(); EXPECT_EQ(TELEMETRY_STREAMING(), true); logicalSwitchesTimerTick(); evalLogicalSwitches(); EXPECT_EQ(getSwitch(SWSRC_SW1), false); logicalSwitchesTimerTick(); evalLogicalSwitches(); EXPECT_EQ(getSwitch(SWSRC_SW1), false); //now set RSSI to 100, L1 should become TRUE for 0.5s TELEMETRY_RSSI() = 100; evalLogicalSwitches(); EXPECT_EQ(TELEMETRY_STREAMING(), true); logicalSwitchesTimerTick(); evalLogicalSwitches(); EXPECT_EQ(getSwitch(SWSRC_SW1), true); logicalSwitchesTimerTick(); evalLogicalSwitches(); EXPECT_EQ(getSwitch(SWSRC_SW1), true); logicalSwitchesTimerTick(); evalLogicalSwitches(); EXPECT_EQ(getSwitch(SWSRC_SW1), true); logicalSwitchesTimerTick(); evalLogicalSwitches(); EXPECT_EQ(getSwitch(SWSRC_SW1), true); logicalSwitchesTimerTick(); evalLogicalSwitches(); EXPECT_EQ(getSwitch(SWSRC_SW1), false); logicalSwitchesTimerTick(); evalLogicalSwitches(); EXPECT_EQ(getSwitch(SWSRC_SW1), false); //repeat telemetry streaming OFF and ON to test for duration processing TELEMETRY_RSSI() = 0; evalLogicalSwitches(); EXPECT_EQ(TELEMETRY_STREAMING(), false); logicalSwitchesTimerTick(); evalLogicalSwitches(); EXPECT_EQ(getSwitch(SWSRC_SW1), false); //now set RSSI to 100, L1 should become TRUE for 0.5s TELEMETRY_RSSI() = 100; evalLogicalSwitches(); EXPECT_EQ(TELEMETRY_STREAMING(), true); logicalSwitchesTimerTick(); evalLogicalSwitches(); EXPECT_EQ(getSwitch(SWSRC_SW1), true); logicalSwitchesTimerTick(); logicalSwitchesTimerTick(); logicalSwitchesTimerTick(); logicalSwitchesTimerTick(); evalLogicalSwitches(); EXPECT_EQ(getSwitch(SWSRC_SW1), false); }
constexpr int8_t operator"" _i8() { return int8_t(detail::parse_signed<std::int8_t, Digits...>()); }
//Minecart physics loop bool Physics::updateMinecart() { std::vector<MinecartData> &minecarts = ServerInstance->map(map)->minecarts; uint32_t listSize = minecarts.size(); for (int32_t simIt = 0; simIt < listSize; simIt++) { //Check if the cart is suppose to move if(minecarts[simIt].speed.x() != 0 || minecarts[simIt].speed.y() != 0 || minecarts[simIt].speed.z() != 0) { uint64_t timeNow = microTime(); double timeDiff = (timeNow-minecarts[simIt].timestamp*1.0)/1000000.0; //s minecarts[simIt].timestamp = timeNow; vec diff = vec(int8_t(float(minecarts[simIt].speed.x())*(timeDiff)), int8_t(float(minecarts[simIt].speed.y())*(timeDiff)), int8_t(float(minecarts[simIt].speed.z())*(timeDiff)) ); minecarts[simIt].pos = vec(minecarts[simIt].pos.x()+diff.x(), minecarts[simIt].pos.y()+diff.y(), minecarts[simIt].pos.z()+diff.z()); vec blockPos = vec((int)(minecarts[simIt].pos.x()/32), (int)(minecarts[simIt].pos.y()/32), (int)(minecarts[simIt].pos.z()/32)); uint8_t block, meta; ServerInstance->map(map)->getBlock(blockPos.x(), blockPos.y(), blockPos.z(), &block, &meta); bool changed = false; if(block == BLOCK_AIR) { minecarts[simIt].pos.y() -= 32; changed = true; } else if((minecarts[simIt].lastBlock.x() != blockPos.x() || minecarts[simIt].lastBlock.y() != blockPos.y() || minecarts[simIt].lastBlock.z() != blockPos.z()) && block == BLOCK_MINECART_TRACKS) { minecarts[simIt].lastBlock = blockPos; if((meta == FLAT_NS && minecarts[simIt].speed.x() != 0) || (meta == FLAT_EW && minecarts[simIt].speed.z() != 0)) { } else { //z = north //-x = east //Going west if(minecarts[simIt].speed.x() > 0 && meta == CORNER_NW) { minecarts[simIt].speed.z() = -minecarts[simIt].speed.x(); minecarts[simIt].speed.x() = 0; changed = true; } //Going west else if(minecarts[simIt].speed.x() > 0 && meta == CORNER_SW) { minecarts[simIt].speed.z() = minecarts[simIt].speed.x(); minecarts[simIt].speed.x() = 0; changed = true; } //Going east else if(minecarts[simIt].speed.x() < 0 && meta == CORNER_NE) { minecarts[simIt].speed.z() = minecarts[simIt].speed.x(); minecarts[simIt].speed.x() = 0; changed = true; } //Going east else if(minecarts[simIt].speed.x() < 0 && meta == CORNER_SE) { minecarts[simIt].speed.z() = -minecarts[simIt].speed.x(); minecarts[simIt].speed.x() = 0; changed = true; } //Going north else if(minecarts[simIt].speed.z() > 0 && meta == CORNER_NW) { minecarts[simIt].speed.x() = -minecarts[simIt].speed.z(); minecarts[simIt].speed.z() = 0; changed = true; } //Going north else if(minecarts[simIt].speed.z() > 0 && meta == CORNER_NE) { minecarts[simIt].speed.x() = minecarts[simIt].speed.z(); minecarts[simIt].speed.z() = 0; changed = true; } //Going south else if(minecarts[simIt].speed.z() < 0 && meta == CORNER_SE) { minecarts[simIt].speed.x() = -minecarts[simIt].speed.z(); minecarts[simIt].speed.z() = 0; changed = true; } //Going south else if(minecarts[simIt].speed.z() < 0 && meta == CORNER_SW) { minecarts[simIt].speed.x() = minecarts[simIt].speed.z(); minecarts[simIt].speed.z() = 0; changed = true; } } } else { //minecarts[simIt].pos.y() += 32; //changed = true; } //Signal clients about the new pos Packet pkt; if(changed) { minecarts[simIt].pos.x() = blockPos.x()*32; minecarts[simIt].pos.y() = blockPos.y()*32; minecarts[simIt].pos.z() = blockPos.z()*32; pkt = Protocol::entityTeleport(minecarts[simIt].EID, (minecarts[simIt].pos.x()+16.0)/32.0, (minecarts[simIt].pos.y()+16.0)/32.0, (minecarts[simIt].pos.z()+16.0)/32.0, 0, 0); } else { pkt = Protocol::entityRelativeMove(minecarts[simIt].EID,(int8_t)diff.x(),(int8_t)diff.y(),(int8_t)diff.z()); } User::sendAll(pkt); } } return true; }
TEST(TestTable, test_is_column) { tables::table table; table.add_const_column("const_c1", uint32_t(99)); table.add_const_column("const_c2", int8_t(127)); table.add_const_column("const_c3", double(9.9)); table.add_const_column("const_c4", std::string("test_const")); table.add_row(); table.add_column("c1"); table.set_default_value("c1", uint32_t()); table.add_column("c2"); table.set_default_value("c2", int8_t()); table.add_column("c3"); table.set_default_value("c3", double()); table.add_column("c4"); table.set_default_value("c4", std::string()); table.set_value("c1", uint32_t(1)); table.set_value("c2", int8_t(23)); table.set_value("c3", double(2.3)); table.set_value("c4", std::string("test1")); table.add_row(); table.set_value("c1", uint32_t(2)); table.set_value("c2", int8_t(33)); table.set_value("c3", double(3.3)); table.set_value("c4", std::string("test2")); table.add_row(); table.set_value("c1", uint32_t(3)); table.set_value("c2", int8_t(43)); table.set_value("c3", double(4.3)); table.set_value("c4", std::string("test3")); EXPECT_TRUE(table.is_column<uint32_t>("c1")); EXPECT_FALSE(table.is_column<int8_t>("c1")); EXPECT_FALSE(table.is_column<double>("c1")); EXPECT_FALSE(table.is_column<std::string>("c1")); EXPECT_FALSE(table.is_column<uint32_t>("c2")); EXPECT_TRUE(table.is_column<int8_t>("c2")); EXPECT_FALSE(table.is_column<double>("c2")); EXPECT_FALSE(table.is_column<std::string>("c2")); EXPECT_FALSE(table.is_column<uint32_t>("c3")); EXPECT_FALSE(table.is_column<int8_t>("c3")); EXPECT_TRUE(table.is_column<double>("c3")); EXPECT_FALSE(table.is_column<std::string>("c3")); EXPECT_FALSE(table.is_column<uint32_t>("c4")); EXPECT_FALSE(table.is_column<int8_t>("c4")); EXPECT_FALSE(table.is_column<double>("c4")); EXPECT_TRUE(table.is_column<std::string>("c4")); EXPECT_TRUE(table.is_column<uint32_t>("const_c1")); EXPECT_FALSE(table.is_column<int8_t>("const_c1")); EXPECT_FALSE(table.is_column<double>("const_c1")); EXPECT_FALSE(table.is_column<std::string>("const_c1")); EXPECT_FALSE(table.is_column<uint32_t>("const_c2")); EXPECT_TRUE(table.is_column<int8_t>("const_c2")); EXPECT_FALSE(table.is_column<double>("const_c2")); EXPECT_FALSE(table.is_column<std::string>("const_c2")); EXPECT_FALSE(table.is_column<uint32_t>("const_c3")); EXPECT_FALSE(table.is_column<int8_t>("const_c3")); EXPECT_TRUE(table.is_column<double>("const_c3")); EXPECT_FALSE(table.is_column<std::string>("const_c3")); EXPECT_FALSE(table.is_column<uint32_t>("const_c4")); EXPECT_FALSE(table.is_column<int8_t>("const_c4")); EXPECT_FALSE(table.is_column<double>("const_c4")); EXPECT_TRUE(table.is_column<std::string>("const_c4")); std::vector<uint32_t> vuint32_t = table.values_as<uint32_t>("c1"); std::vector<int8_t> vint8_t = table.values_as<int8_t>("c2"); std::vector<double> vdouble = table.values_as<double>("c3"); std::vector<std::string> vstring = table.values_as<std::string>("c4"); std::vector<uint32_t> vconstuint32_t = table.values_as<uint32_t>( "const_c1"); std::vector<int8_t> vconstint8_t = table.values_as<int8_t>("const_c2"); std::vector<double> vconstdouble = table.values_as<double>("const_c3"); std::vector<std::string> vconststring = table.values_as<std::string>( "const_c4"); EXPECT_EQ(uint64_t(3), vuint32_t.size()); EXPECT_EQ(uint64_t(3), vint8_t.size()); EXPECT_EQ(uint64_t(3), vdouble.size()); EXPECT_EQ(uint64_t(3), vstring.size()); EXPECT_EQ(uint64_t(3), vconstuint32_t.size()); EXPECT_EQ(uint64_t(3), vconstint8_t.size()); EXPECT_EQ(uint64_t(3), vconstdouble.size()); EXPECT_EQ(uint64_t(3), vconststring.size()); }
int8_t RhtClient::get_temp(uint8_t *dec) { int8_t val = int8_t(t); *dec = uint8_t(int16_t(t*10)%10); return val; }
int SoapyAudio::readStream( SoapySDR::Stream *stream, void * const *buffs, const size_t numElems, int &flags, long long &timeNs, const long timeoutUs) { if (!dac.isStreamRunning()) { return 0; } if (sampleRateChanged.load()) { if (dac.isStreamRunning()) { dac.stopStream(); } if (dac.isStreamOpen()) { dac.closeStream(); } dac.openStream(NULL, &inputParameters, RTAUDIO_FLOAT32, sampleRate, &bufferLength, &_rx_callback, (void *) this, &opts); dac.startStream(); sampleRateChanged.store(false); } //this is the user's buffer for channel 0 void *buff0 = buffs[0]; //are elements left in the buffer? if not, do a new read. if (bufferedElems == 0 || (sampleOffset && (bufferedElems < abs(sampleOffset)))) { int ret = this->acquireReadBuffer(stream, _currentHandle, (const void **)&_currentBuff, flags, timeNs, timeoutUs); if (ret < 0) return ret; bufferedElems = ret; } size_t returnedElems = std::min(bufferedElems, numElems); if (sampleOffset && (bufferedElems < abs(sampleOffset))) { return 0; } //convert into user's buff0 if (sampleOffset) { if (asFormat == AUDIO_FORMAT_FLOAT32) { float *ftarget = (float *) buff0; std::complex<float> tmp; if (cSetup == FORMAT_MONO_L || cSetup == FORMAT_MONO_R) { for (size_t i = 0; i < returnedElems; i++) { ftarget[i * 2] = _currentBuff[i]; ftarget[i * 2 + 1] = 0; } } else if (cSetup == FORMAT_STEREO_IQ) { if (sampleOffset > 0) { size_t iStart = abs(sampleOffset); for (size_t i = 0; i < iStart; i++) { ftarget[i * 2] = sampleOffsetBuffer[i]; ftarget[i * 2 + 1] = _currentBuff[i * 2 + 1]; } for (size_t i = iStart; i < returnedElems; i++) { ftarget[i * 2] = _currentBuff[(i + iStart) * 2]; ftarget[i * 2 + 1] = _currentBuff[i * 2 + 1]; } for (int i = 0; i < iStart; i++) { sampleOffsetBuffer[i] = _currentBuff[(returnedElems-iStart+i) * 2]; } } else { size_t iStart = abs(sampleOffset); for (size_t i = 0; i < iStart; i++) { ftarget[i * 2] = _currentBuff[i * 2]; ftarget[i * 2 + 1] = sampleOffsetBuffer[i]; } for (size_t i = iStart; i < returnedElems; i++) { ftarget[i * 2] = _currentBuff[i * 2]; ftarget[i * 2 + 1] = _currentBuff[(i + iStart) * 2 + 1]; } for (int i = 0; i < iStart; i++) { sampleOffsetBuffer[i] = _currentBuff[(returnedElems-iStart+i) * 2 + 1]; } } } else if (cSetup == FORMAT_STEREO_QI) { if (sampleOffset > 0) { size_t iStart = abs(sampleOffset); for (size_t i = 0; i < iStart; i++) { ftarget[i * 2 + 1] = sampleOffsetBuffer[i]; ftarget[i * 2] = _currentBuff[i * 2 + 1]; } for (size_t i = iStart; i < returnedElems; i++) { ftarget[i * 2 + 1] = _currentBuff[(i + iStart) * 2]; ftarget[i * 2] = _currentBuff[i * 2 + 1]; } for (int i = 0; i < iStart; i++) { sampleOffsetBuffer[i] = _currentBuff[(returnedElems-iStart+i) * 2]; } } else { size_t iStart = abs(sampleOffset); for (size_t i = 0; i < iStart; i++) { ftarget[i * 2 + 1] = _currentBuff[i * 2]; ftarget[i * 2] = sampleOffsetBuffer[i]; } for (size_t i = iStart; i < returnedElems; i++) { ftarget[i * 2 + 1] = _currentBuff[i * 2]; ftarget[i * 2] = _currentBuff[(i + iStart) * 2 + 1]; } for (int i = 0; i < iStart; i++) { sampleOffsetBuffer[i] = _currentBuff[(returnedElems-iStart+i) * 2 + 1]; } } } } else if (asFormat == AUDIO_FORMAT_INT16) { int16_t *itarget = (int16_t *) buff0; std::complex<int16_t> tmp; if (cSetup == FORMAT_MONO_L || cSetup == FORMAT_MONO_R) { for (size_t i = 0; i < returnedElems; i++) { itarget[i * 2] = int16_t(_currentBuff[i] * 32767.0); itarget[i * 2 + 1] = 0; } } else if (cSetup == FORMAT_STEREO_IQ) { if (sampleOffset > 0) { size_t iStart = abs(sampleOffset); for (size_t i = 0; i < iStart; i++) { itarget[i * 2] = int16_t(sampleOffsetBuffer[i] * 32767.0); itarget[i * 2 + 1] = int16_t(_currentBuff[i * 2 + 1] * 32767.0); } for (size_t i = iStart; i < returnedElems; i++) { itarget[i * 2] = int16_t(_currentBuff[(i + iStart) * 2] * 32767.0); itarget[i * 2 + 1] = int16_t(_currentBuff[i * 2 + 1] * 32767.0); } for (int i = 0; i < iStart; i++) { sampleOffsetBuffer[i] = _currentBuff[(returnedElems-iStart+i) * 2]; } } else { size_t iStart = abs(sampleOffset); for (size_t i = 0; i < iStart; i++) { itarget[i * 2] = int16_t(_currentBuff[i * 2] * 32767.0); itarget[i * 2 + 1] = int16_t(sampleOffsetBuffer[i] * 32767.0); } for (size_t i = iStart; i < returnedElems; i++) { itarget[i * 2] = int16_t(_currentBuff[i * 2] * 32767.0); itarget[i * 2 + 1] = int16_t(_currentBuff[(i + iStart) * 2 + 1] * 32767.0); } for (int i = 0; i < iStart; i++) { sampleOffsetBuffer[i] = _currentBuff[(returnedElems-iStart+i) * 2 + 1]; } } } if (cSetup == FORMAT_STEREO_QI) { if (sampleOffset > 0) { size_t iStart = abs(sampleOffset); for (size_t i = 0; i < iStart; i++) { itarget[i * 2 + 1] = int16_t(sampleOffsetBuffer[i] * 32767.0); itarget[i * 2] = int16_t(_currentBuff[i * 2 + 1] * 32767.0); } for (size_t i = iStart; i < returnedElems; i++) { itarget[i * 2 + 1] = int16_t(_currentBuff[(i + iStart) * 2] * 32767.0); itarget[i * 2] = int16_t(_currentBuff[i * 2 + 1] * 32767.0); } for (int i = 0; i < iStart; i++) { sampleOffsetBuffer[i] = _currentBuff[(returnedElems-iStart+i) * 2]; } } else { size_t iStart = abs(sampleOffset); for (size_t i = 0; i < iStart; i++) { itarget[i * 2 + 1] = int16_t(_currentBuff[i * 2] * 32767.0); itarget[i * 2] = int16_t(sampleOffsetBuffer[i] * 32767.0); } for (size_t i = iStart; i < returnedElems; i++) { itarget[i * 2 + 1] = int16_t(_currentBuff[i * 2] * 32767.0); itarget[i * 2] = int16_t(_currentBuff[(i + iStart) * 2 + 1] * 32767.0); } for (int i = 0; i < iStart; i++) { sampleOffsetBuffer[i] = _currentBuff[(returnedElems-iStart+i) * 2 + 1]; } } } } else if (asFormat == AUDIO_FORMAT_INT8) { int8_t *itarget = (int8_t *) buff0; if (cSetup == FORMAT_MONO_L || cSetup == FORMAT_MONO_R) { for (size_t i = 0; i < returnedElems; i++) { itarget[i * 2] = int8_t(_currentBuff[i] * 127.0); itarget[i * 2 + 1] = 0; } } else if (cSetup == FORMAT_STEREO_IQ) { if (sampleOffset > 0) { size_t iStart = abs(sampleOffset); for (size_t i = 0; i < iStart; i++) { itarget[i * 2] = int16_t(sampleOffsetBuffer[i] * 127.0); itarget[i * 2 + 1] = int16_t(_currentBuff[i * 2 + 1] * 127.0); } for (size_t i = iStart; i < returnedElems; i++) { itarget[i * 2] = int16_t(_currentBuff[(i + iStart) * 2] * 127.0); itarget[i * 2 + 1] = int16_t(_currentBuff[i * 2 + 1] * 127.0); } for (int i = 0; i < iStart; i++) { sampleOffsetBuffer[i] = _currentBuff[(returnedElems-iStart+i) * 2]; } } else { size_t iStart = abs(sampleOffset); for (size_t i = 0; i < iStart; i++) { itarget[i * 2] = int16_t(_currentBuff[i * 2] * 127.0); itarget[i * 2 + 1] = int16_t(sampleOffsetBuffer[i] * 127.0); } for (size_t i = iStart; i < returnedElems; i++) { itarget[i * 2] = int16_t(_currentBuff[i * 2] * 127.0); itarget[i * 2 + 1] = int16_t(_currentBuff[(i + iStart) * 2 + 1] * 127.0); } for (int i = 0; i < iStart; i++) { sampleOffsetBuffer[i] = _currentBuff[(returnedElems-iStart+i) * 2 + 1]; } } } if (cSetup == FORMAT_STEREO_QI) { if (sampleOffset > 0) { size_t iStart = abs(sampleOffset); for (size_t i = 0; i < iStart; i++) { itarget[i * 2 + 1] = int16_t(sampleOffsetBuffer[i] * 127.0); itarget[i * 2] = int16_t(_currentBuff[i * 2 + 1] * 127.0); } for (size_t i = iStart; i < returnedElems; i++) { itarget[i * 2 + 1] = int16_t(_currentBuff[(i + iStart) * 2] * 127.0); itarget[i * 2] = int16_t(_currentBuff[i * 2 + 1] * 127.0); } for (int i = 0; i < iStart; i++) { sampleOffsetBuffer[i] = _currentBuff[(returnedElems-iStart+i) * 2]; } } else { size_t iStart = abs(sampleOffset); for (size_t i = 0; i < iStart; i++) { itarget[i * 2 + 1] = int16_t(_currentBuff[i * 2] * 127.0); itarget[i * 2] = int16_t(sampleOffsetBuffer[i] * 127.0); } for (size_t i = iStart; i < returnedElems; i++) { itarget[i * 2 + 1] = int16_t(_currentBuff[i * 2] * 127.0); itarget[i * 2] = int16_t(_currentBuff[(i + iStart) * 2 + 1] * 127.0); } for (int i = 0; i < iStart; i++) { sampleOffsetBuffer[i] = _currentBuff[(returnedElems-iStart+i) * 2 + 1]; } } } } } else { if (asFormat == AUDIO_FORMAT_FLOAT32) { float *ftarget = (float *) buff0; std::complex<float> tmp; if (cSetup == FORMAT_MONO_L || cSetup == FORMAT_MONO_R) { for (size_t i = 0; i < returnedElems; i++) { ftarget[i * 2] = _currentBuff[i]; ftarget[i * 2 + 1] = 0; } } else if (cSetup == FORMAT_STEREO_IQ) { for (size_t i = 0; i < returnedElems; i++) { ftarget[i * 2] = _currentBuff[i * 2]; ftarget[i * 2 + 1] = _currentBuff[i * 2 + 1]; } } else if (cSetup == FORMAT_STEREO_QI) { for (size_t i = 0; i < returnedElems; i++) { ftarget[i * 2] = _currentBuff[i * 2 + 1]; ftarget[i * 2 + 1] = _currentBuff[i * 2]; } } } else if (asFormat == AUDIO_FORMAT_INT16) { int16_t *itarget = (int16_t *) buff0; std::complex<int16_t> tmp; if (cSetup == FORMAT_MONO_L || cSetup == FORMAT_MONO_R) { for (size_t i = 0; i < returnedElems; i++) { itarget[i * 2] = int16_t(_currentBuff[i] * 32767.0); itarget[i * 2 + 1] = 0; } } else if (cSetup == FORMAT_STEREO_IQ) { for (size_t i = 0; i < returnedElems; i++) { itarget[i * 2] = int16_t(_currentBuff[i * 2] * 32767.0); itarget[i * 2 + 1] = int16_t(_currentBuff[i * 2 + 1] * 32767.0); } } else if (cSetup == FORMAT_STEREO_QI) { for (size_t i = 0; i < returnedElems; i++) { itarget[i * 2] = int16_t(_currentBuff[i * 2 + 1] * 32767.0); itarget[i * 2 + 1] = int16_t(_currentBuff[i * 2] * 32767.0); } } } else if (asFormat == AUDIO_FORMAT_INT8) { int8_t *itarget = (int8_t *) buff0; if (cSetup == FORMAT_MONO_L || cSetup == FORMAT_MONO_R) { for (size_t i = 0; i < returnedElems; i++) { itarget[i * 2] = int8_t(_currentBuff[i] * 127.0); itarget[i * 2 + 1] = 0; } } else if (cSetup == FORMAT_STEREO_IQ) { for (size_t i = 0; i < returnedElems; i++) { itarget[i * 2] = int8_t(_currentBuff[i * 2] * 127.0); itarget[i * 2 + 1] = int8_t(_currentBuff[i * 2 + 1] * 127.0); } } else if (cSetup == FORMAT_STEREO_QI) { for (size_t i = 0; i < returnedElems; i++) { itarget[i * 2] = int8_t(_currentBuff[i * 2 + 1] * 127.0); itarget[i * 2 + 1] = int8_t(_currentBuff[i * 2] * 127.0); } } } } //bump variables for next call into readStream bufferedElems -= returnedElems; _currentBuff += returnedElems * elementsPerSample; //return number of elements written to buff0 if (bufferedElems != 0) flags |= SOAPY_SDR_MORE_FRAGMENTS; else this->releaseReadBuffer(stream, _currentHandle); return returnedElems; }
static void stereo_processing(PSContext *ps, float (*l)[32][2], float (*r)[32][2], int is34) { int e, b, k, n; float (*H11)[PS_MAX_NUM_ENV+1][PS_MAX_NR_IIDICC] = ps->H11; float (*H12)[PS_MAX_NUM_ENV+1][PS_MAX_NR_IIDICC] = ps->H12; float (*H21)[PS_MAX_NUM_ENV+1][PS_MAX_NR_IIDICC] = ps->H21; float (*H22)[PS_MAX_NUM_ENV+1][PS_MAX_NR_IIDICC] = ps->H22; int8_t *opd_hist = ps->opd_hist; int8_t *ipd_hist = ps->ipd_hist; int8_t iid_mapped_buf[PS_MAX_NUM_ENV][PS_MAX_NR_IIDICC]; int8_t icc_mapped_buf[PS_MAX_NUM_ENV][PS_MAX_NR_IIDICC]; int8_t ipd_mapped_buf[PS_MAX_NUM_ENV][PS_MAX_NR_IIDICC]; int8_t opd_mapped_buf[PS_MAX_NUM_ENV][PS_MAX_NR_IIDICC]; int8_t (*iid_mapped)[PS_MAX_NR_IIDICC] = iid_mapped_buf; int8_t (*icc_mapped)[PS_MAX_NR_IIDICC] = icc_mapped_buf; int8_t (*ipd_mapped)[PS_MAX_NR_IIDICC] = ipd_mapped_buf; int8_t (*opd_mapped)[PS_MAX_NR_IIDICC] = opd_mapped_buf; const int8_t *k_to_i = is34 ? k_to_i_34 : k_to_i_20; const float (*H_LUT)[8][4] = (PS_BASELINE || ps->icc_mode < 3) ? HA : HB; //Remapping if (ps->num_env_old) { memcpy(H11[0][0], H11[0][ps->num_env_old], PS_MAX_NR_IIDICC*sizeof(H11[0][0][0])); memcpy(H11[1][0], H11[1][ps->num_env_old], PS_MAX_NR_IIDICC*sizeof(H11[1][0][0])); memcpy(H12[0][0], H12[0][ps->num_env_old], PS_MAX_NR_IIDICC*sizeof(H12[0][0][0])); memcpy(H12[1][0], H12[1][ps->num_env_old], PS_MAX_NR_IIDICC*sizeof(H12[1][0][0])); memcpy(H21[0][0], H21[0][ps->num_env_old], PS_MAX_NR_IIDICC*sizeof(H21[0][0][0])); memcpy(H21[1][0], H21[1][ps->num_env_old], PS_MAX_NR_IIDICC*sizeof(H21[1][0][0])); memcpy(H22[0][0], H22[0][ps->num_env_old], PS_MAX_NR_IIDICC*sizeof(H22[0][0][0])); memcpy(H22[1][0], H22[1][ps->num_env_old], PS_MAX_NR_IIDICC*sizeof(H22[1][0][0])); } if (is34) { remap34(&iid_mapped, ps->iid_par, ps->nr_iid_par, ps->num_env, 1); remap34(&icc_mapped, ps->icc_par, ps->nr_icc_par, ps->num_env, 1); if (ps->enable_ipdopd) { remap34(&ipd_mapped, ps->ipd_par, ps->nr_ipdopd_par, ps->num_env, 0); remap34(&opd_mapped, ps->opd_par, ps->nr_ipdopd_par, ps->num_env, 0); } if (!ps->is34bands_old) { map_val_20_to_34(H11[0][0]); map_val_20_to_34(H11[1][0]); map_val_20_to_34(H12[0][0]); map_val_20_to_34(H12[1][0]); map_val_20_to_34(H21[0][0]); map_val_20_to_34(H21[1][0]); map_val_20_to_34(H22[0][0]); map_val_20_to_34(H22[1][0]); ipdopd_reset(ipd_hist, opd_hist); } } else { remap20(&iid_mapped, ps->iid_par, ps->nr_iid_par, ps->num_env, 1); remap20(&icc_mapped, ps->icc_par, ps->nr_icc_par, ps->num_env, 1); if (ps->enable_ipdopd) { remap20(&ipd_mapped, ps->ipd_par, ps->nr_ipdopd_par, ps->num_env, 0); remap20(&opd_mapped, ps->opd_par, ps->nr_ipdopd_par, ps->num_env, 0); } if (ps->is34bands_old) { map_val_34_to_20(H11[0][0]); map_val_34_to_20(H11[1][0]); map_val_34_to_20(H12[0][0]); map_val_34_to_20(H12[1][0]); map_val_34_to_20(H21[0][0]); map_val_34_to_20(H21[1][0]); map_val_34_to_20(H22[0][0]); map_val_34_to_20(H22[1][0]); ipdopd_reset(ipd_hist, opd_hist); } } //Mixing for (e = 0; e < ps->num_env; e++) { for (b = 0; b < NR_PAR_BANDS[is34]; b++) { float h11, h12, h21, h22; h11 = H_LUT[iid_mapped[e][b] + 7 + 23 * ps->iid_quant][icc_mapped[e][b]][0]; h12 = H_LUT[iid_mapped[e][b] + 7 + 23 * ps->iid_quant][icc_mapped[e][b]][1]; h21 = H_LUT[iid_mapped[e][b] + 7 + 23 * ps->iid_quant][icc_mapped[e][b]][2]; h22 = H_LUT[iid_mapped[e][b] + 7 + 23 * ps->iid_quant][icc_mapped[e][b]][3]; if (!PS_BASELINE && ps->enable_ipdopd && b < ps->nr_ipdopd_par) { //The spec say says to only run this smoother when enable_ipdopd //is set but the reference decoder appears to run it constantly float h11i, h12i, h21i, h22i; float ipd_adj_re, ipd_adj_im; int opd_idx = opd_hist[b] * 8 + opd_mapped[e][b]; int ipd_idx = ipd_hist[b] * 8 + ipd_mapped[e][b]; float opd_re = pd_re_smooth[opd_idx]; float opd_im = pd_im_smooth[opd_idx]; float ipd_re = pd_re_smooth[ipd_idx]; float ipd_im = pd_im_smooth[ipd_idx]; opd_hist[b] = opd_idx & 0x3F; ipd_hist[b] = ipd_idx & 0x3F; ipd_adj_re = opd_re*ipd_re + opd_im*ipd_im; ipd_adj_im = opd_im*ipd_re - opd_re*ipd_im; h11i = h11 * opd_im; h11 = h11 * opd_re; h12i = h12 * ipd_adj_im; h12 = h12 * ipd_adj_re; h21i = h21 * opd_im; h21 = h21 * opd_re; h22i = h22 * ipd_adj_im; h22 = h22 * ipd_adj_re; H11[1][e+1][b] = h11i; H12[1][e+1][b] = h12i; H21[1][e+1][b] = h21i; H22[1][e+1][b] = h22i; } H11[0][e+1][b] = h11; H12[0][e+1][b] = h12; H21[0][e+1][b] = h21; H22[0][e+1][b] = h22; } for (k = 0; k < NR_BANDS[is34]; k++) { float h11r, h12r, h21r, h22r; float h11i, h12i, h21i, h22i; float h11r_step, h12r_step, h21r_step, h22r_step; float h11i_step, h12i_step, h21i_step, h22i_step; int start = ps->border_position[e]; int stop = ps->border_position[e+1]; float width = 1.f / (stop - start); b = k_to_i[k]; h11r = H11[0][e][b]; h12r = H12[0][e][b]; h21r = H21[0][e][b]; h22r = H22[0][e][b]; if (!PS_BASELINE && ps->enable_ipdopd) { //Is this necessary? ps_04_new seems unchanged if ((is34 && k <= 13 && k >= 9) || (!is34 && k <= 1)) { h11i = -H11[1][e][b]; h12i = -H12[1][e][b]; h21i = -H21[1][e][b]; h22i = -H22[1][e][b]; } else { h11i = H11[1][e][b]; h12i = H12[1][e][b]; h21i = H21[1][e][b]; h22i = H22[1][e][b]; } } //Interpolation h11r_step = (H11[0][e+1][b] - h11r) * width; h12r_step = (H12[0][e+1][b] - h12r) * width; h21r_step = (H21[0][e+1][b] - h21r) * width; h22r_step = (H22[0][e+1][b] - h22r) * width; if (!PS_BASELINE && ps->enable_ipdopd) { h11i_step = (H11[1][e+1][b] - h11i) * width; h12i_step = (H12[1][e+1][b] - h12i) * width; h21i_step = (H21[1][e+1][b] - h21i) * width; h22i_step = (H22[1][e+1][b] - h22i) * width; } for (n = start + 1; n <= stop; n++) { //l is s, r is d float l_re = l[k][n][0]; float l_im = l[k][n][1]; float r_re = r[k][n][0]; float r_im = r[k][n][1]; h11r += h11r_step; h12r += h12r_step; h21r += h21r_step; h22r += h22r_step; if (!PS_BASELINE && ps->enable_ipdopd) { h11i += h11i_step; h12i += h12i_step; h21i += h21i_step; h22i += h22i_step; l[k][n][0] = h11r*l_re + h21r*r_re - h11i*l_im - h21i*r_im; l[k][n][1] = h11r*l_im + h21r*r_im + h11i*l_re + h21i*r_re; r[k][n][0] = h12r*l_re + h22r*r_re - h12i*l_im - h22i*r_im; r[k][n][1] = h12r*l_im + h22r*r_im + h12i*l_re + h22i*r_re; } else { l[k][n][0] = h11r*l_re + h21r*r_re; l[k][n][1] = h11r*l_im + h21r*r_im; r[k][n][0] = h12r*l_re + h22r*r_re; r[k][n][1] = h12r*l_im + h22r*r_im; } } } } }
//-------------Dx--------------------------------// int8_t Adns_5020::dx() { uint8_t dx_raw = ADNS_read(dxr); return int8_t(dx_raw); }
//-------------Dy--------------------------------// int8_t Adns_5020::dy() { uint8_t dy_raw = ADNS_read(dyr); return int8_t(dr_raw); }
int main(int argc, char** argv) { double temp = 1.0; // output command for documentation: int i; for (i = 0; i < argc; ++i) printf("%s ", argv[i] ); printf("\n"); if (argc > 1) iterations = atoi(argv[1]); if (argc > 2) init_value = (double) atof(argv[2]); if (argc > 3) temp = (double)atof(argv[3]); // int8_t ::fill(data8, data8+SIZE, int8_t(init_value)); int8_t var1int8_1, var1int8_2, var1int8_3, var1int8_4; var1int8_1 = int8_t(temp); var1int8_2 = var1int8_1 * int8_t(2); var1int8_3 = var1int8_1 + int8_t(2); var1int8_4 = var1int8_1 + var1int8_2 / var1int8_3; // test moving redundant calcs out of loop test_variable1< int8_t, custom_add_variable<int8_t> > (data8, SIZE, var1int8_1, "int8_t variable add"); test_hoisted_variable1< int8_t, custom_add_variable<int8_t> > (data8, SIZE, var1int8_1, "int8_t variable add hoisted"); test_variable4< int8_t, custom_add_multiple_variable<int8_t> > (data8, SIZE, var1int8_1, var1int8_2, var1int8_3, var1int8_4, "int8_t multiple variable adds"); test_variable1< int8_t, custom_sub_variable<int8_t> > (data8, SIZE, var1int8_1, "int8_t variable subtract"); test_variable4< int8_t, custom_sub_multiple_variable<int8_t> > (data8, SIZE, var1int8_1, var1int8_2, var1int8_3, var1int8_4, "int8_t multiple variable subtracts"); test_variable1< int8_t, custom_multiply_variable<int8_t> > (data8, SIZE, var1int8_1, "int8_t variable multiply"); test_variable4< int8_t, custom_multiply_multiple_variable<int8_t> > (data8, SIZE, var1int8_1, var1int8_2, var1int8_3, var1int8_4, "int8_t multiple variable multiplies"); test_variable4< int8_t, custom_multiply_multiple_variable2<int8_t> > (data8, SIZE, var1int8_1, var1int8_2, var1int8_3, var1int8_4, "int8_t multiple variable multiplies2"); test_variable1< int8_t, custom_divide_variable<int8_t> > (data8, SIZE, var1int8_1, "int8_t variable divide"); test_variable4< int8_t, custom_divide_multiple_variable<int8_t> > (data8, SIZE, var1int8_1, var1int8_2, var1int8_3, var1int8_4, "int8_t multiple variable divides"); test_variable4< int8_t, custom_divide_multiple_variable2<int8_t> > (data8, SIZE, var1int8_1, var1int8_2, var1int8_3, var1int8_4, "int8_t multiple variable divides2"); test_variable4< int8_t, custom_mixed_multiple_variable<int8_t> > (data8, SIZE, var1int8_1, var1int8_2, var1int8_3, var1int8_4, "int8_t multiple variable mixed"); test_variable1< int8_t, custom_variable_and<int8_t> > (data8, SIZE, var1int8_1, "int8_t variable and"); test_variable4< int8_t, custom_multiple_variable_and<int8_t> > (data8, SIZE, var1int8_1, var1int8_2, var1int8_3, var1int8_4, "int8_t multiple variable and"); test_variable1< int8_t, custom_variable_or<int8_t> > (data8, SIZE, var1int8_1, "int8_t variable or"); test_variable4< int8_t, custom_multiple_variable_or<int8_t> > (data8, SIZE, var1int8_1, var1int8_2, var1int8_3, var1int8_4, "int8_t multiple variable or"); test_variable1< int8_t, custom_variable_xor<int8_t> > (data8, SIZE, var1int8_1, "int8_t variable xor"); test_variable4< int8_t, custom_multiple_variable_xor<int8_t> > (data8, SIZE, var1int8_1, var1int8_2, var1int8_3, var1int8_4, "int8_t multiple variable xor"); summarize("int8_t loop invariant", SIZE, iterations, kDontShowGMeans, kDontShowPenalty ); // unsigned8 ::fill(data8unsigned, data8unsigned+SIZE, uint8_t(init_value)); uint8_t var1uint8_1, var1uint8_2, var1uint8_3, var1uint8_4; var1uint8_1 = uint8_t(temp); var1uint8_2 = var1uint8_1 * uint8_t(2); var1uint8_3 = var1uint8_1 + uint8_t(2); var1uint8_4 = var1uint8_1 + var1uint8_2 / var1uint8_3; // test moving redundant calcs out of loop test_variable1< uint8_t, custom_add_variable<uint8_t> > (data8unsigned, SIZE, var1uint8_1, "uint8_t variable add"); test_hoisted_variable1< uint8_t, custom_add_variable<uint8_t> > (data8unsigned, SIZE, var1uint8_1, "uint8_t variable add hoisted"); test_variable4< uint8_t, custom_add_multiple_variable<uint8_t> > (data8unsigned, SIZE, var1uint8_1, var1uint8_2, var1uint8_3, var1uint8_4, "uint8_t multiple variable adds"); test_variable1< uint8_t, custom_sub_variable<uint8_t> > (data8unsigned, SIZE, var1uint8_1, "uint8_t variable subtract"); test_variable4< uint8_t, custom_sub_multiple_variable<uint8_t> > (data8unsigned, SIZE, var1uint8_1, var1uint8_2, var1uint8_3, var1uint8_4, "uint8_t multiple variable subtracts"); test_variable1< uint8_t, custom_multiply_variable<uint8_t> > (data8unsigned, SIZE, var1uint8_1, "uint8_t variable multiply"); test_variable4< uint8_t, custom_multiply_multiple_variable<uint8_t> > (data8unsigned, SIZE, var1uint8_1, var1uint8_2, var1uint8_3, var1uint8_4, "uint8_t multiple variable multiplies"); test_variable4< uint8_t, custom_multiply_multiple_variable2<uint8_t> > (data8unsigned, SIZE, var1uint8_1, var1uint8_2, var1uint8_3, var1uint8_4, "uint8_t multiple variable multiplies2"); test_variable1< uint8_t, custom_divide_variable<uint8_t> > (data8unsigned, SIZE, var1uint8_1, "uint8_t variable divide"); test_variable4< uint8_t, custom_divide_multiple_variable<uint8_t> > (data8unsigned, SIZE, var1uint8_1, var1uint8_2, var1uint8_3, var1uint8_4, "uint8_t multiple variable divides"); test_variable4< uint8_t, custom_divide_multiple_variable2<uint8_t> > (data8unsigned, SIZE, var1uint8_1, var1uint8_2, var1uint8_3, var1uint8_4, "uint8_t multiple variable divides2"); test_variable4< uint8_t, custom_mixed_multiple_variable<uint8_t> > (data8unsigned, SIZE, var1uint8_1, var1uint8_2, var1uint8_3, var1uint8_4, "uint8_t multiple variable mixed"); test_variable1< uint8_t, custom_variable_and<uint8_t> > (data8unsigned, SIZE, var1uint8_1, "uint8_t variable and"); test_variable4< uint8_t, custom_multiple_variable_and<uint8_t> > (data8unsigned, SIZE, var1uint8_1, var1uint8_2, var1uint8_3, var1uint8_4, "uint8_t multiple variable and"); test_variable1< uint8_t, custom_variable_or<uint8_t> > (data8unsigned, SIZE, var1uint8_1, "uint8_t variable or"); test_variable4< uint8_t, custom_multiple_variable_or<uint8_t> > (data8unsigned, SIZE, var1uint8_1, var1uint8_2, var1uint8_3, var1uint8_4, "uint8_t multiple variable or"); test_variable1< uint8_t, custom_variable_xor<uint8_t> > (data8unsigned, SIZE, var1uint8_1, "uint8_t variable xor"); test_variable4< uint8_t, custom_multiple_variable_xor<uint8_t> > (data8unsigned, SIZE, var1uint8_1, var1uint8_2, var1uint8_3, var1uint8_4, "uint8_t multiple variable xor"); summarize("uint8_t loop invariant", SIZE, iterations, kDontShowGMeans, kDontShowPenalty ); // int16_t ::fill(data16, data16+SIZE, int16_t(init_value)); int16_t var1int16_1, var1int16_2, var1int16_3, var1int16_4; var1int16_1 = int16_t(temp); var1int16_2 = var1int16_1 * int16_t(2); var1int16_3 = var1int16_1 + int16_t(2); var1int16_4 = var1int16_1 + var1int16_2 / var1int16_3; // test moving redundant calcs out of loop test_variable1< int16_t, custom_add_variable<int16_t> > (data16, SIZE, var1int16_1, "int16_t variable add"); test_hoisted_variable1< int16_t, custom_add_variable<int16_t> > (data16, SIZE, var1int16_1, "int16_t variable add hoisted"); test_variable4< int16_t, custom_add_multiple_variable<int16_t> > (data16, SIZE, var1int16_1, var1int16_2, var1int16_3, var1int16_4, "int16_t multiple variable adds"); test_variable1< int16_t, custom_sub_variable<int16_t> > (data16, SIZE, var1int16_1, "int16_t variable subtract"); test_variable4< int16_t, custom_sub_multiple_variable<int16_t> > (data16, SIZE, var1int16_1, var1int16_2, var1int16_3, var1int16_4, "int16_t multiple variable subtracts"); test_variable1< int16_t, custom_multiply_variable<int16_t> > (data16, SIZE, var1int16_1, "int16_t variable multiply"); test_variable4< int16_t, custom_multiply_multiple_variable<int16_t> > (data16, SIZE, var1int16_1, var1int16_2, var1int16_3, var1int16_4, "int16_t multiple variable multiplies"); test_variable4< int16_t, custom_multiply_multiple_variable2<int16_t> > (data16, SIZE, var1int16_1, var1int16_2, var1int16_3, var1int16_4, "int16_t multiple variable multiplies2"); test_variable1< int16_t, custom_divide_variable<int16_t> > (data16, SIZE, var1int16_1, "int16_t variable divide"); test_variable4< int16_t, custom_divide_multiple_variable<int16_t> > (data16, SIZE, var1int16_1, var1int16_2, var1int16_3, var1int16_4, "int16_t multiple variable divides"); test_variable4< int16_t, custom_divide_multiple_variable2<int16_t> > (data16, SIZE, var1int16_1, var1int16_2, var1int16_3, var1int16_4, "int16_t multiple variable divides2"); test_variable4< int16_t, custom_mixed_multiple_variable<int16_t> > (data16, SIZE, var1int16_1, var1int16_2, var1int16_3, var1int16_4, "int16_t multiple variable mixed"); test_variable1< int16_t, custom_variable_and<int16_t> > (data16, SIZE, var1int16_1, "int16_t variable and"); test_variable4< int16_t, custom_multiple_variable_and<int16_t> > (data16, SIZE, var1int16_1, var1int16_2, var1int16_3, var1int16_4, "int16_t multiple variable and"); test_variable1< int16_t, custom_variable_or<int16_t> > (data16, SIZE, var1int16_1, "int16_t variable or"); test_variable4< int16_t, custom_multiple_variable_or<int16_t> > (data16, SIZE, var1int16_1, var1int16_2, var1int16_3, var1int16_4, "int16_t multiple variable or"); test_variable1< int16_t, custom_variable_xor<int16_t> > (data16, SIZE, var1int16_1, "int16_t variable xor"); test_variable4< int16_t, custom_multiple_variable_xor<int16_t> > (data16, SIZE, var1int16_1, var1int16_2, var1int16_3, var1int16_4, "int16_t multiple variable xor"); summarize("int16_t loop invariant", SIZE, iterations, kDontShowGMeans, kDontShowPenalty ); // unsigned16 ::fill(data16unsigned, data16unsigned+SIZE, uint16_t(init_value)); uint16_t var1uint16_1, var1uint16_2, var1uint16_3, var1uint16_4; var1uint16_1 = uint16_t(temp); var1uint16_2 = var1uint16_1 * uint16_t(2); var1uint16_3 = var1uint16_1 + uint16_t(2); var1uint16_4 = var1uint16_1 + var1uint16_2 / var1uint16_3; // test moving redundant calcs out of loop test_variable1< uint16_t, custom_add_variable<uint16_t> > (data16unsigned, SIZE, var1uint16_1, "uint16_t variable add"); test_hoisted_variable1< uint16_t, custom_add_variable<uint16_t> > (data16unsigned, SIZE, var1uint16_1, "uint16_t variable add hoisted"); test_variable4< uint16_t, custom_add_multiple_variable<uint16_t> > (data16unsigned, SIZE, var1uint16_1, var1uint16_2, var1uint16_3, var1uint16_4, "uint16_t multiple variable adds"); test_variable1< uint16_t, custom_sub_variable<uint16_t> > (data16unsigned, SIZE, var1uint16_1, "uint16_t variable subtract"); test_variable4< uint16_t, custom_sub_multiple_variable<uint16_t> > (data16unsigned, SIZE, var1uint16_1, var1uint16_2, var1uint16_3, var1uint16_4, "uint16_t multiple variable subtracts"); test_variable1< uint16_t, custom_multiply_variable<uint16_t> > (data16unsigned, SIZE, var1uint16_1, "uint16_t variable multiply"); test_variable4< uint16_t, custom_multiply_multiple_variable<uint16_t> > (data16unsigned, SIZE, var1uint16_1, var1uint16_2, var1uint16_3, var1uint16_4, "uint16_t multiple variable multiplies"); test_variable4< uint16_t, custom_multiply_multiple_variable2<uint16_t> > (data16unsigned, SIZE, var1uint16_1, var1uint16_2, var1uint16_3, var1uint16_4, "uint16_t multiple variable multiplies2"); test_variable1< uint16_t, custom_divide_variable<uint16_t> > (data16unsigned, SIZE, var1uint16_1, "uint16_t variable divide"); test_variable4< uint16_t, custom_divide_multiple_variable<uint16_t> > (data16unsigned, SIZE, var1uint16_1, var1uint16_2, var1uint16_3, var1uint16_4, "uint16_t multiple variable divides"); test_variable4< uint16_t, custom_divide_multiple_variable2<uint16_t> > (data16unsigned, SIZE, var1uint16_1, var1uint16_2, var1uint16_3, var1uint16_4, "uint16_t multiple variable divides2"); test_variable4< uint16_t, custom_mixed_multiple_variable<uint16_t> > (data16unsigned, SIZE, var1uint16_1, var1uint16_2, var1uint16_3, var1uint16_4, "uint16_t multiple variable mixed"); test_variable1< uint16_t, custom_variable_and<uint16_t> > (data16unsigned, SIZE, var1uint16_1, "uint16_t variable and"); test_variable4< uint16_t, custom_multiple_variable_and<uint16_t> > (data16unsigned, SIZE, var1uint16_1, var1uint16_2, var1uint16_3, var1uint16_4, "uint16_t multiple variable and"); test_variable1< uint16_t, custom_variable_or<uint16_t> > (data16unsigned, SIZE, var1uint16_1, "uint16_t variable or"); test_variable4< uint16_t, custom_multiple_variable_or<uint16_t> > (data16unsigned, SIZE, var1uint16_1, var1uint16_2, var1uint16_3, var1uint16_4, "uint16_t multiple variable or"); test_variable1< uint16_t, custom_variable_xor<uint16_t> > (data16unsigned, SIZE, var1uint16_1, "uint16_t variable xor"); test_variable4< uint16_t, custom_multiple_variable_xor<uint16_t> > (data16unsigned, SIZE, var1uint16_1, var1uint16_2, var1uint16_3, var1uint16_4, "uint16_t multiple variable xor"); summarize("uint16_t loop invariant", SIZE, iterations, kDontShowGMeans, kDontShowPenalty ); // int32_t ::fill(data32, data32+SIZE, int32_t(init_value)); int32_t var1int32_1, var1int32_2, var1int32_3, var1int32_4; var1int32_1 = int32_t(temp); var1int32_2 = var1int32_1 * int32_t(2); var1int32_3 = var1int32_1 + int32_t(2); var1int32_4 = var1int32_1 + var1int32_2 / var1int32_3; // test moving redundant calcs out of loop test_variable1< int32_t, custom_add_variable<int32_t> > (data32, SIZE, var1int32_1, "int32_t variable add"); test_hoisted_variable1< int32_t, custom_add_variable<int32_t> > (data32, SIZE, var1int32_1, "int32_t variable add hoisted"); test_variable4< int32_t, custom_add_multiple_variable<int32_t> > (data32, SIZE, var1int32_1, var1int32_2, var1int32_3, var1int32_4, "int32_t multiple variable adds"); test_variable1< int32_t, custom_sub_variable<int32_t> > (data32, SIZE, var1int32_1, "int32_t variable subtract"); test_variable4< int32_t, custom_sub_multiple_variable<int32_t> > (data32, SIZE, var1int32_1, var1int32_2, var1int32_3, var1int32_4, "int32_t multiple variable subtracts"); test_variable1< int32_t, custom_multiply_variable<int32_t> > (data32, SIZE, var1int32_1, "int32_t variable multiply"); test_variable4< int32_t, custom_multiply_multiple_variable<int32_t> > (data32, SIZE, var1int32_1, var1int32_2, var1int32_3, var1int32_4, "int32_t multiple variable multiplies"); test_variable4< int32_t, custom_multiply_multiple_variable2<int32_t> > (data32, SIZE, var1int32_1, var1int32_2, var1int32_3, var1int32_4, "int32_t multiple variable multiplies2"); test_variable1< int32_t, custom_divide_variable<int32_t> > (data32, SIZE, var1int32_1, "int32_t variable divide"); test_variable4< int32_t, custom_divide_multiple_variable<int32_t> > (data32, SIZE, var1int32_1, var1int32_2, var1int32_3, var1int32_4, "int32_t multiple variable divides"); test_variable4< int32_t, custom_divide_multiple_variable2<int32_t> > (data32, SIZE, var1int32_1, var1int32_2, var1int32_3, var1int32_4, "int32_t multiple variable divides2"); test_variable4< int32_t, custom_mixed_multiple_variable<int32_t> > (data32, SIZE, var1int32_1, var1int32_2, var1int32_3, var1int32_4, "int32_t multiple variable mixed"); test_variable1< int32_t, custom_variable_and<int32_t> > (data32, SIZE, var1int32_1, "int32_t variable and"); test_variable4< int32_t, custom_multiple_variable_and<int32_t> > (data32, SIZE, var1int32_1, var1int32_2, var1int32_3, var1int32_4, "int32_t multiple variable and"); test_variable1< int32_t, custom_variable_or<int32_t> > (data32, SIZE, var1int32_1, "int32_t variable or"); test_variable4< int32_t, custom_multiple_variable_or<int32_t> > (data32, SIZE, var1int32_1, var1int32_2, var1int32_3, var1int32_4, "int32_t multiple variable or"); test_variable1< int32_t, custom_variable_xor<int32_t> > (data32, SIZE, var1int32_1, "int32_t variable xor"); test_variable4< int32_t, custom_multiple_variable_xor<int32_t> > (data32, SIZE, var1int32_1, var1int32_2, var1int32_3, var1int32_4, "int32_t multiple variable xor"); summarize("int32_t loop invariant", SIZE, iterations, kDontShowGMeans, kDontShowPenalty ); // unsigned32 ::fill(data32unsigned, data32unsigned+SIZE, uint32_t(init_value)); uint32_t var1uint32_1, var1uint32_2, var1uint32_3, var1uint32_4; var1uint32_1 = uint32_t(temp); var1uint32_2 = var1uint32_1 * uint32_t(2); var1uint32_3 = var1uint32_1 + uint32_t(2); var1uint32_4 = var1uint32_1 + var1uint32_2 / var1uint32_3; // test moving redundant calcs out of loop test_variable1< uint32_t, custom_add_variable<uint32_t> > (data32unsigned, SIZE, var1uint32_1, "uint32_t variable add"); test_hoisted_variable1< uint32_t, custom_add_variable<uint32_t> > (data32unsigned, SIZE, var1uint32_1, "uint32_t variable add hoisted"); test_variable4< uint32_t, custom_add_multiple_variable<uint32_t> > (data32unsigned, SIZE, var1uint32_1, var1uint32_2, var1uint32_3, var1uint32_4, "uint32_t multiple variable adds"); test_variable1< uint32_t, custom_sub_variable<uint32_t> > (data32unsigned, SIZE, var1uint32_1, "uint32_t variable subtract"); test_variable4< uint32_t, custom_sub_multiple_variable<uint32_t> > (data32unsigned, SIZE, var1uint32_1, var1uint32_2, var1uint32_3, var1uint32_4, "uint32_t multiple variable subtracts"); test_variable1< uint32_t, custom_multiply_variable<uint32_t> > (data32unsigned, SIZE, var1uint32_1, "uint32_t variable multiply"); test_variable4< uint32_t, custom_multiply_multiple_variable<uint32_t> > (data32unsigned, SIZE, var1uint32_1, var1uint32_2, var1uint32_3, var1uint32_4, "uint32_t multiple variable multiplies"); test_variable4< uint32_t, custom_multiply_multiple_variable2<uint32_t> > (data32unsigned, SIZE, var1uint32_1, var1uint32_2, var1uint32_3, var1uint32_4, "uint32_t multiple variable multiplies2"); test_variable1< uint32_t, custom_divide_variable<uint32_t> > (data32unsigned, SIZE, var1uint32_1, "uint32_t variable divide"); test_variable4< uint32_t, custom_divide_multiple_variable<uint32_t> > (data32unsigned, SIZE, var1uint32_1, var1uint32_2, var1uint32_3, var1uint32_4, "uint32_t multiple variable divides"); test_variable4< uint32_t, custom_divide_multiple_variable2<uint32_t> > (data32unsigned, SIZE, var1uint32_1, var1uint32_2, var1uint32_3, var1uint32_4, "uint32_t multiple variable divides2"); test_variable4< uint32_t, custom_mixed_multiple_variable<uint32_t> > (data32unsigned, SIZE, var1uint32_1, var1uint32_2, var1uint32_3, var1uint32_4, "uint32_t multiple variable mixed"); test_variable1< uint32_t, custom_variable_and<uint32_t> > (data32unsigned, SIZE, var1uint32_1, "uint32_t variable and"); test_variable4< uint32_t, custom_multiple_variable_and<uint32_t> > (data32unsigned, SIZE, var1uint32_1, var1uint32_2, var1uint32_3, var1uint32_4, "uint32_t multiple variable and"); test_variable1< uint32_t, custom_variable_or<uint32_t> > (data32unsigned, SIZE, var1uint32_1, "uint32_t variable or"); test_variable4< uint32_t, custom_multiple_variable_or<uint32_t> > (data32unsigned, SIZE, var1uint32_1, var1uint32_2, var1uint32_3, var1uint32_4, "uint32_t multiple variable or"); test_variable1< uint32_t, custom_variable_xor<uint32_t> > (data32unsigned, SIZE, var1uint32_1, "uint32_t variable xor"); test_variable4< uint32_t, custom_multiple_variable_xor<uint32_t> > (data32unsigned, SIZE, var1uint32_1, var1uint32_2, var1uint32_3, var1uint32_4, "uint32_t multiple variable xor"); summarize("uint32_t loop invariant", SIZE, iterations, kDontShowGMeans, kDontShowPenalty ); // int64_t ::fill(data64, data64+SIZE, int64_t(init_value)); int64_t var1int64_1, var1int64_2, var1int64_3, var1int64_4; var1int64_1 = int64_t(temp); var1int64_2 = var1int64_1 * int64_t(2); var1int64_3 = var1int64_1 + int64_t(2); var1int64_4 = var1int64_1 + var1int64_2 / var1int64_3; // test moving redundant calcs out of loop test_variable1< int64_t, custom_add_variable<int64_t> > (data64, SIZE, var1int64_1, "int64_t variable add"); test_hoisted_variable1< int64_t, custom_add_variable<int64_t> > (data64, SIZE, var1int64_1, "int64_t variable add hoisted"); test_variable4< int64_t, custom_add_multiple_variable<int64_t> > (data64, SIZE, var1int64_1, var1int64_2, var1int64_3, var1int64_4, "int64_t multiple variable adds"); test_variable1< int64_t, custom_sub_variable<int64_t> > (data64, SIZE, var1int64_1, "int64_t variable subtract"); test_variable4< int64_t, custom_sub_multiple_variable<int64_t> > (data64, SIZE, var1int64_1, var1int64_2, var1int64_3, var1int64_4, "int64_t multiple variable subtracts"); test_variable1< int64_t, custom_multiply_variable<int64_t> > (data64, SIZE, var1int64_1, "int64_t variable multiply"); test_variable4< int64_t, custom_multiply_multiple_variable<int64_t> > (data64, SIZE, var1int64_1, var1int64_2, var1int64_3, var1int64_4, "int64_t multiple variable multiplies"); test_variable4< int64_t, custom_multiply_multiple_variable2<int64_t> > (data64, SIZE, var1int64_1, var1int64_2, var1int64_3, var1int64_4, "int64_t multiple variable multiplies2"); test_variable1< int64_t, custom_divide_variable<int64_t> > (data64, SIZE, var1int64_1, "int64_t variable divide"); test_variable4< int64_t, custom_divide_multiple_variable<int64_t> > (data64, SIZE, var1int64_1, var1int64_2, var1int64_3, var1int64_4, "int64_t multiple variable divides"); test_variable4< int64_t, custom_divide_multiple_variable2<int64_t> > (data64, SIZE, var1int64_1, var1int64_2, var1int64_3, var1int64_4, "int64_t multiple variable divides2"); test_variable4< int64_t, custom_mixed_multiple_variable<int64_t> > (data64, SIZE, var1int64_1, var1int64_2, var1int64_3, var1int64_4, "int64_t multiple variable mixed"); test_variable1< int64_t, custom_variable_and<int64_t> > (data64, SIZE, var1int64_1, "int64_t variable and"); test_variable4< int64_t, custom_multiple_variable_and<int64_t> > (data64, SIZE, var1int64_1, var1int64_2, var1int64_3, var1int64_4, "int64_t multiple variable and"); test_variable1< int64_t, custom_variable_or<int64_t> > (data64, SIZE, var1int64_1, "int64_t variable or"); test_variable4< int64_t, custom_multiple_variable_or<int64_t> > (data64, SIZE, var1int64_1, var1int64_2, var1int64_3, var1int64_4, "int64_t multiple variable or"); test_variable1< int64_t, custom_variable_xor<int64_t> > (data64, SIZE, var1int64_1, "int64_t variable xor"); test_variable4< int64_t, custom_multiple_variable_xor<int64_t> > (data64, SIZE, var1int64_1, var1int64_2, var1int64_3, var1int64_4, "int64_t multiple variable xor"); summarize("int64_t loop invariant", SIZE, iterations, kDontShowGMeans, kDontShowPenalty ); // unsigned64 ::fill(data64unsigned, data64unsigned+SIZE, uint64_t(init_value)); uint64_t var1uint64_1, var1uint64_2, var1uint64_3, var1uint64_4; var1uint64_1 = uint64_t(temp); var1uint64_2 = var1uint64_1 * uint64_t(2); var1uint64_3 = var1uint64_1 + uint64_t(2); var1uint64_4 = var1uint64_1 + var1uint64_2 / var1uint64_3; // test moving redundant calcs out of loop test_variable1< uint64_t, custom_add_variable<uint64_t> > (data64unsigned, SIZE, var1uint64_1, "uint64_t variable add"); test_hoisted_variable1< uint64_t, custom_add_variable<uint64_t> > (data64unsigned, SIZE, var1uint64_1, "uint64_t variable add hoisted"); test_variable4< uint64_t, custom_add_multiple_variable<uint64_t> > (data64unsigned, SIZE, var1uint64_1, var1uint64_2, var1uint64_3, var1uint64_4, "uint64_t multiple variable adds"); test_variable1< uint64_t, custom_sub_variable<uint64_t> > (data64unsigned, SIZE, var1uint64_1, "uint64_t variable subtract"); test_variable4< uint64_t, custom_sub_multiple_variable<uint64_t> > (data64unsigned, SIZE, var1uint64_1, var1uint64_2, var1uint64_3, var1uint64_4, "uint64_t multiple variable subtracts"); test_variable1< uint64_t, custom_multiply_variable<uint64_t> > (data64unsigned, SIZE, var1uint64_1, "uint64_t variable multiply"); test_variable4< uint64_t, custom_multiply_multiple_variable<uint64_t> > (data64unsigned, SIZE, var1uint64_1, var1uint64_2, var1uint64_3, var1uint64_4, "uint64_t multiple variable multiplies"); test_variable4< uint64_t, custom_multiply_multiple_variable2<uint64_t> > (data64unsigned, SIZE, var1uint64_1, var1uint64_2, var1uint64_3, var1uint64_4, "uint64_t multiple variable multiplies2"); test_variable1< uint64_t, custom_divide_variable<uint64_t> > (data64unsigned, SIZE, var1uint64_1, "uint64_t variable divide"); test_variable4< uint64_t, custom_divide_multiple_variable<uint64_t> > (data64unsigned, SIZE, var1uint64_1, var1uint64_2, var1uint64_3, var1uint64_4, "uint64_t multiple variable divides"); test_variable4< uint64_t, custom_divide_multiple_variable2<uint64_t> > (data64unsigned, SIZE, var1uint64_1, var1uint64_2, var1uint64_3, var1uint64_4, "uint64_t multiple variable divides2"); test_variable4< uint64_t, custom_mixed_multiple_variable<uint64_t> > (data64unsigned, SIZE, var1uint64_1, var1uint64_2, var1uint64_3, var1uint64_4, "uint64_t multiple variable mixed"); test_variable1< uint64_t, custom_variable_and<uint64_t> > (data64unsigned, SIZE, var1uint64_1, "uint64_t variable and"); test_variable4< uint64_t, custom_multiple_variable_and<uint64_t> > (data64unsigned, SIZE, var1uint64_1, var1uint64_2, var1uint64_3, var1uint64_4, "uint64_t multiple variable and"); test_variable1< uint64_t, custom_variable_or<uint64_t> > (data64unsigned, SIZE, var1uint64_1, "uint64_t variable or"); test_variable4< uint64_t, custom_multiple_variable_or<uint64_t> > (data64unsigned, SIZE, var1uint64_1, var1uint64_2, var1uint64_3, var1uint64_4, "uint64_t multiple variable or"); test_variable1< uint64_t, custom_variable_xor<uint64_t> > (data64unsigned, SIZE, var1uint64_1, "uint64_t variable xor"); test_variable4< uint64_t, custom_multiple_variable_xor<uint64_t> > (data64unsigned, SIZE, var1uint64_1, var1uint64_2, var1uint64_3, var1uint64_4, "uint64_t multiple variable xor"); summarize("uint64_t loop invariant", SIZE, iterations, kDontShowGMeans, kDontShowPenalty ); // float ::fill(dataFloat, dataFloat+SIZE, float(init_value)); float var1Float_1, var1Float_2, var1Float_3, var1Float_4; var1Float_1 = float(temp); var1Float_2 = var1Float_1 * float(2.0); var1Float_3 = var1Float_1 + float(2.0); var1Float_4 = var1Float_1 + var1Float_2 / var1Float_3; // test moving redundant calcs out of loop test_variable1< float, custom_add_variable<float> > (dataFloat, SIZE, var1Float_1, "float variable add"); test_hoisted_variable1< float, custom_add_variable<float> > (dataFloat, SIZE, var1Float_1, "float variable add hoisted"); test_variable4< float, custom_add_multiple_variable<float> > (dataFloat, SIZE, var1Float_1, var1Float_2, var1Float_3, var1Float_4, "float multiple variable adds"); test_variable1< float, custom_sub_variable<float> > (dataFloat, SIZE, var1Float_1, "float variable subtract"); test_variable4< float, custom_sub_multiple_variable<float> > (dataFloat, SIZE, var1Float_1, var1Float_2, var1Float_3, var1Float_4, "float multiple variable subtracts"); test_variable1< float, custom_multiply_variable<float> > (dataFloat, SIZE, var1Float_1, "float variable multiply"); test_variable4< float, custom_multiply_multiple_variable<float> > (dataFloat, SIZE, var1Float_1, var1Float_2, var1Float_3, var1Float_4, "float multiple variable multiplies"); test_variable4< float, custom_multiply_multiple_variable2<float> > (dataFloat, SIZE, var1Float_1, var1Float_2, var1Float_3, var1Float_4, "float multiple variable multiplies2"); test_variable1< float, custom_divide_variable<float> > (dataFloat, SIZE, var1Float_1, "float variable divide"); test_variable4< float, custom_divide_multiple_variable<float> > (dataFloat, SIZE, var1Float_1, var1Float_2, var1Float_3, var1Float_4, "float multiple variable divides"); test_variable4< float, custom_divide_multiple_variable2<float> > (dataFloat, SIZE, var1Float_1, var1Float_2, var1Float_3, var1Float_4, "float multiple variable divides2"); test_variable4< float, custom_mixed_multiple_variable<float> > (dataFloat, SIZE, var1Float_1, var1Float_2, var1Float_3, var1Float_4, "float multiple variable mixed"); summarize("float loop invariant", SIZE, iterations, kDontShowGMeans, kDontShowPenalty ); // double ::fill(dataDouble, dataDouble+SIZE, double(init_value)); double var1Double_1, var1Double_2, var1Double_3, var1Double_4; var1Double_1 = double(temp); var1Double_2 = var1Double_1 * double(2.0); var1Double_3 = var1Double_1 + double(2.0); var1Double_4 = var1Double_1 + var1Double_2 / var1Double_3; // test moving redundant calcs out of loop test_variable1< double, custom_add_variable<double> > (dataDouble, SIZE, var1Double_1, "double variable add"); test_hoisted_variable1< double, custom_add_variable<double> > (dataDouble, SIZE, var1Double_1, "double variable add hoisted"); test_variable4< double, custom_add_multiple_variable<double> > (dataDouble, SIZE, var1Double_1, var1Double_2, var1Double_3, var1Double_4, "double multiple variable adds"); test_variable1< double, custom_sub_variable<double> > (dataDouble, SIZE, var1Double_1, "double variable subtract"); test_variable4< double, custom_sub_multiple_variable<double> > (dataDouble, SIZE, var1Double_1, var1Double_2, var1Double_3, var1Double_4, "double multiple variable subtracts"); test_variable1< double, custom_multiply_variable<double> > (dataDouble, SIZE, var1Double_1, "double variable multiply"); test_variable4< double, custom_multiply_multiple_variable<double> > (dataDouble, SIZE, var1Double_1, var1Double_2, var1Double_3, var1Double_4, "double multiple variable multiplies"); test_variable4< double, custom_multiply_multiple_variable2<double> > (dataDouble, SIZE, var1Double_1, var1Double_2, var1Double_3, var1Double_4, "double multiple variable multiplies2"); test_variable1< double, custom_divide_variable<double> > (dataDouble, SIZE, var1Double_1, "double variable divide"); test_variable4< double, custom_divide_multiple_variable<double> > (dataDouble, SIZE, var1Double_1, var1Double_2, var1Double_3, var1Double_4, "double multiple variable divides"); test_variable4< double, custom_divide_multiple_variable2<double> > (dataDouble, SIZE, var1Double_1, var1Double_2, var1Double_3, var1Double_4, "double multiple variable divides2"); test_variable4< double, custom_mixed_multiple_variable<double> > (dataDouble, SIZE, var1Double_1, var1Double_2, var1Double_3, var1Double_4, "double multiple variable mixed"); summarize("double loop invariant", SIZE, iterations, kDontShowGMeans, kDontShowPenalty ); return 0; }
int main(int argc, char **argv) { Fl_Window *w = (Fl_Window *) 0; Ep128Emu::VirtualMachine *vm = (Ep128Emu::VirtualMachine *) 0; Ep128Emu::AudioOutput *audioOutput = (Ep128Emu::AudioOutput *) 0; #ifdef ENABLE_MIDI_PORT Ep128Emu::MIDIPort *midiPort = (Ep128Emu::MIDIPort *) 0; #endif Ep128Emu::EmulatorConfiguration *config = (Ep128Emu::EmulatorConfiguration *) 0; Ep128Emu::VMThread *vmThread = (Ep128Emu::VMThread *) 0; Ep128EmuGUI *gui_ = (Ep128EmuGUI *) 0; const char *cfgFileName = "ep128cfg.dat"; Ep128Emu::File *snapshotFile = (Ep128Emu::File *) 0; int snapshotNameIndex = 0; int colorScheme = 0; int8_t machineType = -1; // 0: EP (default), 1: ZX, 2: CPC, 3: TVC int8_t retval = 0; #ifdef DISABLE_OPENGL_DISPLAY bool glEnabled = false; #else bool glEnabled = true; bool glCanDoSingleBuf = false; bool glCanDoDoubleBuf = false; #endif bool configLoaded = false; #ifdef WIN32 timeBeginPeriod(1U); #else // set machine type if the program name in argv[0] begins with // "zx", "cpc" or "tvc" for (size_t i = 0; argv[0][i] != '\0'; i++) { if (i == 0 || argv[0][i] == '/') { if (argv[0][i] == '/') i++; if (std::strncmp(argv[0] + i, "zx", 2) == 0) machineType = 1; else if (std::strncmp(argv[0] + i, "cpc", 3) == 0) machineType = 2; else if (std::strncmp(argv[0] + i, "tvc", 3) == 0) machineType = 3; else machineType = -1; } } #endif try { // find out machine type to be emulated for (int i = 1; i < argc; i++) { if (std::strcmp(argv[i], "-cfg") == 0 && i < (argc - 1)) { i++; } else if (std::strcmp(argv[i], "-snapshot") == 0) { if (++i >= argc) throw Ep128Emu::Exception("missing snapshot file name"); snapshotNameIndex = i; } else if (std::strcmp(argv[i], "-colorscheme") == 0) { if (++i >= argc) throw Ep128Emu::Exception("missing color scheme number"); colorScheme = int(std::atoi(argv[i])); colorScheme = (colorScheme >= 0 && colorScheme <= 3 ? colorScheme : 0); } else if (std::strcmp(argv[i], "-ep128") == 0) { machineType = 0; } else if (std::strcmp(argv[i], "-zx") == 0) { machineType = 1; } else if (std::strcmp(argv[i], "-cpc") == 0) { machineType = 2; } else if (std::strcmp(argv[i], "-tvc") == 0) { machineType = 3; } #ifndef DISABLE_OPENGL_DISPLAY else if (std::strcmp(argv[i], "-opengl") == 0) { glEnabled = true; } #endif else if (std::strcmp(argv[i], "-no-opengl") == 0) { glEnabled = false; } else if (std::strcmp(argv[i], "-h") == 0 || std::strcmp(argv[i], "-help") == 0 || std::strcmp(argv[i], "--help") == 0) { std::fprintf(stderr, "Usage: %s [OPTIONS...]\n", argv[0]); std::fprintf(stderr, "The allowed options are:\n"); std::fprintf(stderr, " -h | -help | --help " "print this message\n"); std::fprintf(stderr, " -ep128 | -zx | -cpc | -tvc\n " "select the type of machine to be emulated\n"); std::fprintf(stderr, " -cfg <FILENAME> " "load ASCII format configuration file\n"); std::fprintf(stderr, " -snapshot <FNAME> " "load snapshot or demo file on startup\n"); #ifndef DISABLE_OPENGL_DISPLAY std::fprintf(stderr, " -opengl " "use OpenGL video driver (this is the default)\n"); #endif std::fprintf(stderr, " -no-opengl " "use software video driver\n"); std::fprintf(stderr, " -colorscheme <N> " "use GUI color scheme N (0, 1, 2, or 3)\n"); std::fprintf(stderr, " OPTION=VALUE " "set configuration variable 'OPTION' to 'VALUE'\n"); std::fprintf(stderr, " OPTION " "set boolean configuration variable 'OPTION' to true\n"); #ifdef WIN32 timeEndPeriod(1U); #endif return 0; } } Fl::lock(); Ep128Emu::setGUIColorScheme(colorScheme); audioOutput = new Ep128Emu::AudioOutput_PortAudio(); #ifndef DISABLE_OPENGL_DISPLAY if (glEnabled) { glCanDoSingleBuf = bool(Fl_Gl_Window::can_do(FL_RGB | FL_SINGLE)); glCanDoDoubleBuf = bool(Fl_Gl_Window::can_do(FL_RGB | FL_DOUBLE)); if (glCanDoSingleBuf | glCanDoDoubleBuf) w = new Ep128Emu::OpenGLDisplay(32, 32, 384, 288, ""); else glEnabled = false; } #endif if (!glEnabled) w = new Ep128Emu::FLTKDisplay(32, 32, 384, 288, ""); w->end(); if (snapshotNameIndex > 0) { snapshotFile = new Ep128Emu::File(argv[snapshotNameIndex], false); if (machineType < 0) machineType = getSnapshotType(*snapshotFile); } if (machineType == 1) { cfgFileName = "zx128cfg.dat"; vm = new ZX128::ZX128VM(*(dynamic_cast<Ep128Emu::VideoDisplay *>(w)), *audioOutput); } else if (machineType == 2) { cfgFileName = "cpc_cfg.dat"; vm = new CPC464::CPC464VM(*(dynamic_cast<Ep128Emu::VideoDisplay *>(w)), *audioOutput); } else if (machineType == 3) { cfgFileName = "tvc_cfg.dat"; vm = new TVC64::TVC64VM(*(dynamic_cast<Ep128Emu::VideoDisplay *>(w)), *audioOutput); } else { vm = new Ep128::Ep128VM(*(dynamic_cast<Ep128Emu::VideoDisplay *>(w)), *audioOutput); } #ifdef ENABLE_MIDI_PORT midiPort = new Ep128Emu::MIDIPort(*vm); #endif config = new Ep128Emu::EmulatorConfiguration( *vm, *(dynamic_cast<Ep128Emu::VideoDisplay *>(w)), *audioOutput #ifdef ENABLE_MIDI_PORT , *midiPort #endif ); config->setErrorCallback(&cfgErrorFunc, (void *) 0); // load base configuration (if available) { Ep128Emu::File *f = (Ep128Emu::File *) 0; #ifndef WIN32 std::string baseDir(Ep128Emu::getEp128EmuHomeDirectory()); bool makecfgNeeded = false; bool makecfgDone = false; #endif try { try { f = new Ep128Emu::File(cfgFileName, true); } catch (Ep128Emu::Exception& e) { #ifndef WIN32 makecfgNeeded = true; } while (true) { if (makecfgNeeded) #endif { std::string cmdLine = "\""; cmdLine += argv[0]; size_t i = cmdLine.length(); while (i > 1) { i--; if (cmdLine[i] == '/' || cmdLine[i] == '\\') { i++; break; } } cmdLine.resize(i); #ifdef WIN32 cmdLine += "makecfg\""; #else # ifndef __APPLE__ cmdLine += "epmakecfg\" -c \""; # else cmdLine += "epmakecfg\" -f \""; # endif cmdLine += baseDir; cmdLine += '"'; makecfgDone = true; #endif std::system(cmdLine.c_str()); } f = new Ep128Emu::File(cfgFileName, true); #ifndef WIN32 config->registerChunkType(*f); f->processAllChunks(); delete f; f = (Ep128Emu::File *) 0; if (makecfgDone) break; // check if there is a valid ROM image on segment 0x00 makecfgNeeded = config->memory.rom[0x00].file.empty(); if (!makecfgNeeded) { std::FILE *tmp = Ep128Emu::fileOpen(config->memory.rom[0x00].file.c_str(), "rb"); makecfgNeeded = (!tmp); if (!makecfgNeeded) { std::fclose(tmp); break; } // get install directory from existing configuration std::string romName; Ep128Emu::splitPath(config->memory.rom[0x00].file, baseDir, romName); DIR *d = (DIR *) 0; if (baseDir.length() > 6 && !romName.empty() && std::strcmp(baseDir.c_str() + (baseDir.length() - 6), "/roms/") == 0) { baseDir.resize(baseDir.length() - 6); d = opendir(baseDir.c_str()); } if (d) closedir(d); else baseDir = Ep128Emu::getEp128EmuHomeDirectory(); } // invalid configuration, try running makecfg if not done yet delete config; config = (Ep128Emu::EmulatorConfiguration *) 0; makecfgNeeded = true; config = new Ep128Emu::EmulatorConfiguration( *vm, *(dynamic_cast<Ep128Emu::VideoDisplay *>(w)), *audioOutput #ifdef ENABLE_MIDI_PORT , *midiPort #endif ); config->setErrorCallback(&cfgErrorFunc, (void *) 0); #endif } #ifdef WIN32 config->registerChunkType(*f); f->processAllChunks(); delete f; #endif } catch (...) { if (f) delete f; } } configLoaded = true; // check command line for any additional configuration for (int i = 1; i < argc; i++) { if (std::strcmp(argv[i], "-ep128") == 0 || std::strcmp(argv[i], "-zx") == 0 || std::strcmp(argv[i], "-cpc") == 0 || std::strcmp(argv[i], "-tvc") == 0 || #ifndef DISABLE_OPENGL_DISPLAY std::strcmp(argv[i], "-opengl") == 0 || #endif std::strcmp(argv[i], "-no-opengl") == 0) continue; if (std::strcmp(argv[i], "-cfg") == 0) { if (++i >= argc) throw Ep128Emu::Exception("missing configuration file name"); config->loadState(argv[i], false); } else if (std::strcmp(argv[i], "-snapshot") == 0 || std::strcmp(argv[i], "-colorscheme") == 0) { i++; } else { const char *s = argv[i]; #ifdef __APPLE__ if (std::strncmp(s, "-psn_", 5) == 0) continue; #endif if (*s == '-') s++; if (*s == '-') s++; const char *p = std::strchr(s, '='); if (!p) (*config)[s] = bool(true); else { std::string optName; while (s != p) { optName += (*s); s++; } p++; (*config)[optName] = p; } } } #ifndef DISABLE_OPENGL_DISPLAY if (glEnabled) { if (config->display.bufferingMode == 0 && !glCanDoSingleBuf) { config->display.bufferingMode = 1; config->displaySettingsChanged = true; } if (config->display.bufferingMode != 0 && !glCanDoDoubleBuf) { config->display.bufferingMode = 0; config->displaySettingsChanged = true; } } #endif config->applySettings(); if (snapshotFile) { vm->registerChunkTypes(*snapshotFile); snapshotFile->processAllChunks(); delete snapshotFile; snapshotFile = (Ep128Emu::File *) 0; } vmThread = new Ep128Emu::VMThread(*vm); gui_ = new Ep128EmuGUI(*(dynamic_cast<Ep128Emu::VideoDisplay *>(w)), *audioOutput, *vm, *vmThread, *config); gui_->run(); } catch (std::exception& e) { if (snapshotFile) { delete snapshotFile; snapshotFile = (Ep128Emu::File *) 0; } if (gui_) { gui_->errorMessage(e.what()); } else { #ifndef WIN32 std::fprintf(stderr, " *** error: %s\n", e.what()); #else (void) MessageBoxA((HWND) 0, (LPCSTR) e.what(), (LPCSTR) "ep128emu error", MB_OK | MB_ICONWARNING); #endif } retval = int8_t(-1); } if (gui_) delete gui_; if (vmThread) delete vmThread; if (config) { if (configLoaded) { try { Ep128Emu::File f; config->saveState(f); f.writeFile(cfgFileName, true); } catch (...) { } } delete config; } #ifdef ENABLE_MIDI_PORT if (midiPort) delete midiPort; #endif if (vm) delete vm; if (w) delete w; if (audioOutput) delete audioOutput; #ifdef WIN32 timeEndPeriod(1U); #endif return int(retval); }
Joystick Joystick::deserialize(std::string input){ Joystick joy; joy.is_xbox = stob(pullObject("\"is_xbox\"", input)); joy.type = std::stoi(pullObject("\"type\"",input)); joy.name = unquote(pullObject("\"name\"", input)); joy.buttons = std::stoi(pullObject("\"buttons\"", input)); joy.button_count = std::stoi(pullObject("\"button_count\"", input)); std::vector<int8_t> axes_deserialized = deserializeList(pullObject("\"axes\"",input), std::function<int8_t(std::string)>([&](std::string input){ return std::stoi(input);}), true); if(axes_deserialized.size() == joy.axes.size()){ joy.axes = axes_deserialized; } else { throw std::out_of_range("Exception: deserialization resulted in array of " + std::to_string(axes_deserialized.size()) + " axes, expected " + std::to_string(joy.axes.size())); } joy.axis_count = std::stoi(pullObject("\"axis_count\"", input)); std::vector<uint8_t> axis_types_deserialized = deserializeList(pullObject("\"axis_types\"",input), std::function<uint8_t(std::string)>([&](std::string input){ return std::stoi(input);}), true); if(axis_types_deserialized.size() == joy.axis_types.size()){ joy.axis_types = axis_types_deserialized; } else { throw std::out_of_range("Exception: deserialization resulted in array of " + std::to_string(axis_types_deserialized.size()) + " axis types, expected " + std::to_string(joy.axis_types.size())); } std::vector<int16_t> povs_deserialized = deserializeList(pullObject("\"povs\"",input), std::function<int16_t(std::string)>([&](std::string input){ return std::stoi(input);}), true); if(povs_deserialized.size() == joy.povs.size()){ joy.povs = povs_deserialized; } else { throw std::out_of_range("Exception: deserialization resulted in array of " + std::to_string(povs_deserialized.size()) + " povs, expected " + std::to_string(joy.povs.size())); } joy.pov_count = std::stoi(pullObject("\"pov_count\"", input)); joy.outputs = std::stoi(pullObject("\"outputs\"", input)); joy.left_rumble = std::stoi(pullObject("\"left_rumble\"", input)); joy.right_rumble = std::stoi(pullObject("\"right_rumble\"", input)); return joy; }
int8_t Int8() { return int8_t(Uint8()); }
bool plResponderModifier::IContinueSending() { // If we haven't been started, exit if (fCurCommand == int8_t(-1)) return false; plResponderState& state = fStates[fCurState]; while (fCurCommand < state.fCmds.Count()) { plMessage *msg = state.fCmds[fCurCommand].fMsg; if (msg) { // If this command needs to wait, and it's condition hasn't been met yet, exit int8_t wait = state.fCmds[fCurCommand].fWaitOn; if (wait != -1 && !fCompletedEvents.IsBitSet(wait)) { ResponderLog(ILog(plStatusLog::kWhite, "Command %d is waiting for command %d(id:%d)", int8_t(fCurCommand)+1, ICmdFromWait(wait)+1, wait)); return false; } if (!(fNotifyMsgFlags & plMessage::kNetNonLocal)|| !IIsLocalOnlyCmd(msg)) { // make sure outgoing msgs inherit net flags as part of cascade uint32_t msgFlags = msg->GetAllBCastFlags(); plNetClientApp::InheritNetMsgFlags(fNotifyMsgFlags, &msgFlags, true); msg->SetAllBCastFlags(msgFlags); // If this is a responder message, let it know which player triggered this if (plResponderMsg* responderMsg = plResponderMsg::ConvertNoRef(msg)) { responderMsg->fPlayerKey = fPlayerKey; } else if (plNotifyMsg* notifyMsg = plNotifyMsg::ConvertNoRef(msg)) { bool foundCollision = false; // If we find a collision event, this message is meant to trigger a multistage for (int i = 0; i < notifyMsg->GetEventCount(); i++) { proEventData* event = notifyMsg->GetEventRecord(i); if (event->fEventType == proEventData::kCollision) { proCollisionEventData* collisionEvent = (proCollisionEventData*)event; collisionEvent->fHitter = fPlayerKey; foundCollision = true; } } // No collision event, this message is for notifying the triggerer if (!foundCollision) { notifyMsg->ClearReceivers(); notifyMsg->AddReceiver(fTriggerer); } notifyMsg->SetSender(GetKey()); } else if (plLinkToAgeMsg* linkMsg = plLinkToAgeMsg::ConvertNoRef(msg)) { if (linkMsg->GetNumReceivers() == 0) { plUoid netUoid(kNetClientMgr_KEY); plKey netKey = hsgResMgr::ResMgr()->FindKey(netUoid); hsAssert(netKey,"NetClientMgr not found"); linkMsg->AddReceiver(netKey); } } else if (plArmatureEffectStateMsg* stateMsg = plArmatureEffectStateMsg::ConvertNoRef(msg)) { stateMsg->ClearReceivers(); stateMsg->AddReceiver(fPlayerKey); stateMsg->fAddSurface = fEnter; } else if (plSubWorldMsg* swMsg = plSubWorldMsg::ConvertNoRef(msg)) { plArmatureMod *avatar = plAvatarMgr::GetInstance()->GetLocalAvatar(); if(avatar) { swMsg->AddReceiver(avatar->GetKey()); } } // If we're in anim debug mode, check if this is an anim play // message so we can put up the cue if (fDebugAnimBox) { plAnimCmdMsg* animMsg = plAnimCmdMsg::ConvertNoRef(msg); if (animMsg && animMsg->Cmd(plAnimCmdMsg::kContinue)) IDebugPlayMsg(animMsg); } if (plTimerCallbackMsg *timerMsg = plTimerCallbackMsg::ConvertNoRef(msg)) { hsRefCnt_SafeRef(timerMsg); plgTimerCallbackMgr::NewTimer(timerMsg->fTime, timerMsg); } else { hsRefCnt_SafeRef(msg); plgDispatch::MsgSend(msg); } } } fCurCommand++; DirtySynchState(kSDLResponder, 0); } // Make sure all callbacks we need to wait on are done before allowing a state switch or restart for (int i = 0; i < state.fNumCallbacks; i++) { if (!fCompletedEvents.IsBitSet(i)) { ResponderLog(ILog(plStatusLog::kWhite, "Can't reset, waiting for command %d(id:%d)", ICmdFromWait(i)+1, i)); return false; } } ResponderLog(ILog(plStatusLog::kGreen, "Reset")); fCurCommand = -1; ISetResponderState(state.fSwitchToState); DirtySynchState(kSDLResponder, 0); return true; }
int PacketHandler::player_digging(User* user) { int8_t status; int32_t x; int16_t y; int8_t temp_y; int32_t z; int8_t direction; uint8_t block; uint8_t meta; BlockBasicPtr blockcb; BlockDefault blockD; user->buffer >> status >> x >> temp_y >> z >> direction; y = (uint8_t)temp_y; if (!user->buffer) { return PACKET_NEED_MORE_DATA; } user->buffer.removePacket(); if (!ServerInstance->map(user->pos.map)->getBlock(x, y, z, &block, &meta)) { blockD.revertBlock(user, x, y, z, user->pos.map); return PACKET_OK; } // Blocks that break with first hit if (status == BLOCK_STATUS_STARTED_DIGGING && (block == BLOCK_SNOW || block == BLOCK_REED || block == BLOCK_TORCH || block == BLOCK_REDSTONE_WIRE || block == BLOCK_RED_ROSE || block == BLOCK_YELLOW_FLOWER || block == BLOCK_BROWN_MUSHROOM || block == BLOCK_RED_MUSHROOM || block == BLOCK_REDSTONE_TORCH_OFF || block == BLOCK_REDSTONE_TORCH_ON)) { status = BLOCK_STATUS_BLOCK_BROKEN; } switch (status) { case BLOCK_STATUS_STARTED_DIGGING: { (static_cast<Hook5<bool, const char*, int32_t, int16_t, int32_t, int8_t>*>(ServerInstance->plugin()->getHook("PlayerDiggingStarted")))->doAll(user->nick.c_str(), x, y, z, direction); for (uint32_t i = 0 ; i < ServerInstance->plugin()->getBlockCB().size(); i++) { blockcb = ServerInstance->plugin()->getBlockCB()[i]; if (blockcb != NULL && blockcb->affectedBlock(block)) { blockcb->onStartedDigging(user, status, x, y, z, user->pos.map, direction); } } break; } case BLOCK_STATUS_BLOCK_BROKEN: { //Player tool usage calculation etc bool rightUse; int16_t itemSlot = user->currentItemSlot() + 36; int16_t itemHealth = ServerInstance->inventory()->itemHealth(user->inv[itemSlot].getType(), block, rightUse); if (itemHealth > 0) { user->inv[itemSlot].incHealth(); if (!rightUse) { user->inv[itemSlot].incHealth(); } if (itemHealth <= user->inv[itemSlot].getHealth()) { user->inv[itemSlot].decCount(); if (user->inv[itemSlot].getCount() == 0) { user->inv[itemSlot].setHealth(0); user->inv[itemSlot].setType(-1); } } ServerInstance->inventory()->setSlot(user, WINDOW_PLAYER, itemSlot, user->inv[itemSlot].getType(), user->inv[itemSlot].getCount(), user->inv[itemSlot].getHealth()); } if ((static_cast<Hook4<bool, const char*, int32_t, int16_t, int32_t>*>(ServerInstance->plugin()->getHook("BlockBreakPre")))->doUntilFalse(user->nick.c_str(), x, y, z)) { blockD.revertBlock(user, x, y, z, user->pos.map); return PACKET_OK; } (static_cast<Hook4<bool, const char*, int32_t, int16_t, int32_t>*>(ServerInstance->plugin()->getHook("BlockBreakPost")))->doAll(user->nick.c_str(), x, y, z); for (uint32_t i = 0 ; i < ServerInstance->plugin()->getBlockCB().size(); i++) { blockcb = ServerInstance->plugin()->getBlockCB()[i]; if (blockcb != NULL && blockcb->affectedBlock(block)) { if (blockcb->onBroken(user, status, x, y, z, user->pos.map, direction)) { // Do not break return PACKET_OK; } else { break; } } } /* notify neighbour blocks of the broken block */ status = block; if (ServerInstance->map(user->pos.map)->getBlock(x + 1, y, z, &block, &meta) && block != BLOCK_AIR) { (static_cast<Hook7<bool, const char*, int32_t, int16_t, int32_t, int32_t, int8_t, int32_t>*>(ServerInstance->plugin()->getHook("BlockNeighbourBreak")))->doAll(user->nick.c_str(), x + 1, y, z, x, int8_t(y), z); for (uint32_t i = 0 ; i < ServerInstance->plugin()->getBlockCB().size(); i++) { blockcb = ServerInstance->plugin()->getBlockCB()[i]; if (blockcb != NULL && (blockcb->affectedBlock(status) || blockcb->affectedBlock(block))) { blockcb->onNeighbourBroken(user, status, x + 1, y, z, user->pos.map, BLOCK_SOUTH); } } } if (ServerInstance->map(user->pos.map)->getBlock(x - 1, y, z, &block, &meta) && block != BLOCK_AIR) { (static_cast<Hook7<bool, const char*, int32_t, int16_t, int32_t, int32_t, int8_t, int32_t>*>(ServerInstance->plugin()->getHook("BlockNeighbourBreak")))->doAll(user->nick.c_str(), x - 1, y, z, x, int8_t(y), z); for (uint32_t i = 0 ; i < ServerInstance->plugin()->getBlockCB().size(); i++) { blockcb = ServerInstance->plugin()->getBlockCB()[i]; if (blockcb != NULL && (blockcb->affectedBlock(status) || blockcb->affectedBlock(block))) { blockcb->onNeighbourBroken(user, status, x - 1, y, z, user->pos.map, BLOCK_NORTH); } } } if (ServerInstance->map(user->pos.map)->getBlock(x, y + 1, z, &block, &meta) && block != BLOCK_AIR) { (static_cast<Hook7<bool, const char*, int32_t, int16_t, int32_t, int32_t, int8_t, int32_t>*>(ServerInstance->plugin()->getHook("BlockNeighbourBreak")))->doAll(user->nick.c_str(), x, y + 1, z, x, int8_t(y), z); for (uint32_t i = 0 ; i < ServerInstance->plugin()->getBlockCB().size(); i++) { blockcb = ServerInstance->plugin()->getBlockCB()[i]; if (blockcb != NULL && (blockcb->affectedBlock(status) || blockcb->affectedBlock(block))) { blockcb->onNeighbourBroken(user, status, x, y + 1, z, user->pos.map, BLOCK_TOP); } } } if (ServerInstance->map(user->pos.map)->getBlock(x, y - 1, z, &block, &meta) && block != BLOCK_AIR) { (static_cast<Hook7<bool, const char*, int32_t, int16_t, int32_t, int32_t, int8_t, int32_t>*>(ServerInstance->plugin()->getHook("BlockNeighbourBreak")))->doAll(user->nick.c_str(), x, y - 1, z, x, int8_t(y), z); for (uint32_t i = 0 ; i < ServerInstance->plugin()->getBlockCB().size(); i++) { blockcb = ServerInstance->plugin()->getBlockCB()[i]; if (blockcb != NULL && (blockcb->affectedBlock(status) || blockcb->affectedBlock(block))) { blockcb->onNeighbourBroken(user, status, x, y - 1, z, user->pos.map, BLOCK_BOTTOM); } } } if (ServerInstance->map(user->pos.map)->getBlock(x, y, z + 1, &block, &meta) && block != BLOCK_AIR) { (static_cast<Hook7<bool, const char*, int32_t, int16_t, int32_t, int32_t, int8_t, int32_t>*>(ServerInstance->plugin()->getHook("BlockNeighbourBreak")))->doAll(user->nick.c_str(), x, y, z + 1, x, int8_t(y), z); for (uint32_t i = 0 ; i < ServerInstance->plugin()->getBlockCB().size(); i++) { blockcb = ServerInstance->plugin()->getBlockCB()[i]; if (blockcb != NULL && (blockcb->affectedBlock(status) || blockcb->affectedBlock(block))) { blockcb->onNeighbourBroken(user, status, x, y, z + 1, user->pos.map, BLOCK_WEST); } } } if (ServerInstance->map(user->pos.map)->getBlock(x, y, z - 1, &block, &meta) && block != BLOCK_AIR) { (static_cast<Hook7<bool, const char*, int32_t, int16_t, int32_t, int32_t, int8_t, int32_t>*>(ServerInstance->plugin()->getHook("BlockNeighbourBreak")))->doAll(user->nick.c_str(), x, y, z - 1, x, int8_t(y), z); for (uint32_t i = 0 ; i < ServerInstance->plugin()->getBlockCB().size(); i++) { blockcb = ServerInstance->plugin()->getBlockCB()[i]; if (blockcb != NULL && (blockcb->affectedBlock(status) || blockcb->affectedBlock(block))) { blockcb->onNeighbourBroken(user, status, x, y, z - 1, user->pos.map, BLOCK_EAST); } } } break; } case BLOCK_STATUS_PICKUP_SPAWN: { //ToDo: handle #define itemSlot (36+user->currentItemSlot()) if (user->inv[itemSlot].getType() > 0) { ServerInstance->map(user->pos.map)->createPickupSpawn(int(user->pos.x), int(user->pos.y), int(user->pos.z), int(user->inv[itemSlot].getType()), 1, int(user->inv[itemSlot].getHealth()), user); user->inv[itemSlot].decCount(); } break; #undef itemSlot } } return PACKET_OK; }
void path_trace(DeviceTask *task, SplitRenderTile& rtile, int2 max_render_feasible_tile_size) { /* cast arguments to cl types */ cl_mem d_data = CL_MEM_PTR(const_mem_map["__data"]->device_pointer); cl_mem d_buffer = CL_MEM_PTR(rtile.buffer); cl_mem d_rng_state = CL_MEM_PTR(rtile.rng_state); cl_int d_x = rtile.x; cl_int d_y = rtile.y; cl_int d_w = rtile.w; cl_int d_h = rtile.h; cl_int d_offset = rtile.offset; cl_int d_stride = rtile.stride; /* Make sure that set render feasible tile size is a multiple of local * work size dimensions. */ assert(max_render_feasible_tile_size.x % SPLIT_KERNEL_LOCAL_SIZE_X == 0); assert(max_render_feasible_tile_size.y % SPLIT_KERNEL_LOCAL_SIZE_Y == 0); size_t global_size[2]; size_t local_size[2] = {SPLIT_KERNEL_LOCAL_SIZE_X, SPLIT_KERNEL_LOCAL_SIZE_Y}; /* Set the range of samples to be processed for every ray in * path-regeneration logic. */ cl_int start_sample = rtile.start_sample; cl_int end_sample = rtile.start_sample + rtile.num_samples; cl_int num_samples = rtile.num_samples; #ifdef __WORK_STEALING__ global_size[0] = (((d_w - 1) / local_size[0]) + 1) * local_size[0]; global_size[1] = (((d_h - 1) / local_size[1]) + 1) * local_size[1]; unsigned int num_parallel_samples = 1; #else global_size[1] = (((d_h - 1) / local_size[1]) + 1) * local_size[1]; unsigned int num_threads = max_render_feasible_tile_size.x * max_render_feasible_tile_size.y; unsigned int num_tile_columns_possible = num_threads / global_size[1]; /* Estimate number of parallel samples that can be * processed in parallel. */ unsigned int num_parallel_samples = min(num_tile_columns_possible / d_w, rtile.num_samples); /* Wavefront size in AMD is 64. * TODO(sergey): What about other platforms? */ if(num_parallel_samples >= 64) { /* TODO(sergey): Could use generic round-up here. */ num_parallel_samples = (num_parallel_samples / 64) * 64; } assert(num_parallel_samples != 0); global_size[0] = d_w * num_parallel_samples; #endif /* __WORK_STEALING__ */ assert(global_size[0] * global_size[1] <= max_render_feasible_tile_size.x * max_render_feasible_tile_size.y); /* Allocate all required global memory once. */ if(first_tile) { size_t num_global_elements = max_render_feasible_tile_size.x * max_render_feasible_tile_size.y; /* TODO(sergey): This will actually over-allocate if * particular kernel does not support multiclosure. */ size_t shaderdata_size = get_shader_data_size(current_max_closure); #ifdef __WORK_STEALING__ /* Calculate max groups */ size_t max_global_size[2]; size_t tile_x = max_render_feasible_tile_size.x; size_t tile_y = max_render_feasible_tile_size.y; max_global_size[0] = (((tile_x - 1) / local_size[0]) + 1) * local_size[0]; max_global_size[1] = (((tile_y - 1) / local_size[1]) + 1) * local_size[1]; max_work_groups = (max_global_size[0] * max_global_size[1]) / (local_size[0] * local_size[1]); /* Allocate work_pool_wgs memory. */ work_pool_wgs = mem_alloc(max_work_groups * sizeof(unsigned int)); #endif /* __WORK_STEALING__ */ /* Allocate queue_index memory only once. */ Queue_index = mem_alloc(NUM_QUEUES * sizeof(int)); use_queues_flag = mem_alloc(sizeof(char)); kgbuffer = mem_alloc(get_KernelGlobals_size()); /* Create global buffers for ShaderData. */ sd = mem_alloc(num_global_elements * shaderdata_size); sd_DL_shadow = mem_alloc(num_global_elements * 2 * shaderdata_size); /* Creation of global memory buffers which are shared among * the kernels. */ rng_coop = mem_alloc(num_global_elements * sizeof(RNG)); throughput_coop = mem_alloc(num_global_elements * sizeof(float3)); L_transparent_coop = mem_alloc(num_global_elements * sizeof(float)); PathRadiance_coop = mem_alloc(num_global_elements * sizeof(PathRadiance)); Ray_coop = mem_alloc(num_global_elements * sizeof(Ray)); PathState_coop = mem_alloc(num_global_elements * sizeof(PathState)); Intersection_coop = mem_alloc(num_global_elements * sizeof(Intersection)); AOAlpha_coop = mem_alloc(num_global_elements * sizeof(float3)); AOBSDF_coop = mem_alloc(num_global_elements * sizeof(float3)); AOLightRay_coop = mem_alloc(num_global_elements * sizeof(Ray)); BSDFEval_coop = mem_alloc(num_global_elements * sizeof(BsdfEval)); ISLamp_coop = mem_alloc(num_global_elements * sizeof(int)); LightRay_coop = mem_alloc(num_global_elements * sizeof(Ray)); Intersection_coop_shadow = mem_alloc(2 * num_global_elements * sizeof(Intersection)); #ifdef WITH_CYCLES_DEBUG debugdata_coop = mem_alloc(num_global_elements * sizeof(DebugData)); #endif ray_state = mem_alloc(num_global_elements * sizeof(char)); hostRayStateArray = (char *)calloc(num_global_elements, sizeof(char)); assert(hostRayStateArray != NULL && "Can't create hostRayStateArray memory"); Queue_data = mem_alloc(num_global_elements * (NUM_QUEUES * sizeof(int)+sizeof(int))); work_array = mem_alloc(num_global_elements * sizeof(unsigned int)); per_sample_output_buffers = mem_alloc(num_global_elements * per_thread_output_buffer_size); } cl_int dQueue_size = global_size[0] * global_size[1]; cl_uint start_arg_index = kernel_set_args(program_data_init(), 0, kgbuffer, sd_DL_shadow, d_data, per_sample_output_buffers, d_rng_state, rng_coop, throughput_coop, L_transparent_coop, PathRadiance_coop, Ray_coop, PathState_coop, Intersection_coop_shadow, ray_state); /* TODO(sergey): Avoid map lookup here. */ #define KERNEL_TEX(type, ttype, name) \ set_kernel_arg_mem(program_data_init(), &start_arg_index, #name); #include "kernel_textures.h" #undef KERNEL_TEX start_arg_index += kernel_set_args(program_data_init(), start_arg_index, start_sample, d_x, d_y, d_w, d_h, d_offset, d_stride, rtile.rng_state_offset_x, rtile.rng_state_offset_y, rtile.buffer_rng_state_stride, Queue_data, Queue_index, dQueue_size, use_queues_flag, work_array, #ifdef __WORK_STEALING__ work_pool_wgs, num_samples, #endif #ifdef WITH_CYCLES_DEBUG debugdata_coop, #endif num_parallel_samples); kernel_set_args(program_scene_intersect(), 0, kgbuffer, d_data, rng_coop, Ray_coop, PathState_coop, Intersection_coop, ray_state, d_w, d_h, Queue_data, Queue_index, dQueue_size, use_queues_flag, #ifdef WITH_CYCLES_DEBUG debugdata_coop, #endif num_parallel_samples); kernel_set_args(program_lamp_emission(), 0, kgbuffer, d_data, throughput_coop, PathRadiance_coop, Ray_coop, PathState_coop, Intersection_coop, ray_state, d_w, d_h, Queue_data, Queue_index, dQueue_size, use_queues_flag, num_parallel_samples); kernel_set_args(program_queue_enqueue(), 0, Queue_data, Queue_index, ray_state, dQueue_size); kernel_set_args(program_background_buffer_update(), 0, kgbuffer, d_data, per_sample_output_buffers, d_rng_state, rng_coop, throughput_coop, PathRadiance_coop, Ray_coop, PathState_coop, L_transparent_coop, ray_state, d_w, d_h, d_x, d_y, d_stride, rtile.rng_state_offset_x, rtile.rng_state_offset_y, rtile.buffer_rng_state_stride, work_array, Queue_data, Queue_index, dQueue_size, end_sample, start_sample, #ifdef __WORK_STEALING__ work_pool_wgs, num_samples, #endif #ifdef WITH_CYCLES_DEBUG debugdata_coop, #endif num_parallel_samples); kernel_set_args(program_shader_eval(), 0, kgbuffer, d_data, sd, rng_coop, Ray_coop, PathState_coop, Intersection_coop, ray_state, Queue_data, Queue_index, dQueue_size); kernel_set_args(program_holdout_emission_blurring_pathtermination_ao(), 0, kgbuffer, d_data, sd, per_sample_output_buffers, rng_coop, throughput_coop, L_transparent_coop, PathRadiance_coop, PathState_coop, Intersection_coop, AOAlpha_coop, AOBSDF_coop, AOLightRay_coop, d_w, d_h, d_x, d_y, d_stride, ray_state, work_array, Queue_data, Queue_index, dQueue_size, #ifdef __WORK_STEALING__ start_sample, #endif num_parallel_samples); kernel_set_args(program_direct_lighting(), 0, kgbuffer, d_data, sd, rng_coop, PathState_coop, ISLamp_coop, LightRay_coop, BSDFEval_coop, ray_state, Queue_data, Queue_index, dQueue_size); kernel_set_args(program_shadow_blocked(), 0, kgbuffer, d_data, PathState_coop, LightRay_coop, AOLightRay_coop, ray_state, Queue_data, Queue_index, dQueue_size); kernel_set_args(program_next_iteration_setup(), 0, kgbuffer, d_data, sd, rng_coop, throughput_coop, PathRadiance_coop, Ray_coop, PathState_coop, LightRay_coop, ISLamp_coop, BSDFEval_coop, AOLightRay_coop, AOBSDF_coop, AOAlpha_coop, ray_state, Queue_data, Queue_index, dQueue_size, use_queues_flag); kernel_set_args(program_sum_all_radiance(), 0, d_data, d_buffer, per_sample_output_buffers, num_parallel_samples, d_w, d_h, d_stride, rtile.buffer_offset_x, rtile.buffer_offset_y, rtile.buffer_rng_state_stride, start_sample); /* Macro for Enqueuing split kernels. */ #define GLUE(a, b) a ## b #define ENQUEUE_SPLIT_KERNEL(kernelName, globalSize, localSize) \ { \ ciErr = clEnqueueNDRangeKernel(cqCommandQueue, \ GLUE(program_, \ kernelName)(), \ 2, \ NULL, \ globalSize, \ localSize, \ 0, \ NULL, \ NULL); \ opencl_assert_err(ciErr, "clEnqueueNDRangeKernel"); \ if(ciErr != CL_SUCCESS) { \ string message = string_printf("OpenCL error: %s in clEnqueueNDRangeKernel()", \ clewErrorString(ciErr)); \ opencl_error(message); \ return; \ } \ } (void) 0 /* Enqueue ckPathTraceKernel_data_init kernel. */ ENQUEUE_SPLIT_KERNEL(data_init, global_size, local_size); bool activeRaysAvailable = true; /* Record number of time host intervention has been made */ unsigned int numHostIntervention = 0; unsigned int numNextPathIterTimes = PathIteration_times; bool canceled = false; while(activeRaysAvailable) { /* Twice the global work size of other kernels for * ckPathTraceKernel_shadow_blocked_direct_lighting. */ size_t global_size_shadow_blocked[2]; global_size_shadow_blocked[0] = global_size[0] * 2; global_size_shadow_blocked[1] = global_size[1]; /* Do path-iteration in host [Enqueue Path-iteration kernels. */ for(int PathIter = 0; PathIter < PathIteration_times; PathIter++) { ENQUEUE_SPLIT_KERNEL(scene_intersect, global_size, local_size); ENQUEUE_SPLIT_KERNEL(lamp_emission, global_size, local_size); ENQUEUE_SPLIT_KERNEL(queue_enqueue, global_size, local_size); ENQUEUE_SPLIT_KERNEL(background_buffer_update, global_size, local_size); ENQUEUE_SPLIT_KERNEL(shader_eval, global_size, local_size); ENQUEUE_SPLIT_KERNEL(holdout_emission_blurring_pathtermination_ao, global_size, local_size); ENQUEUE_SPLIT_KERNEL(direct_lighting, global_size, local_size); ENQUEUE_SPLIT_KERNEL(shadow_blocked, global_size_shadow_blocked, local_size); ENQUEUE_SPLIT_KERNEL(next_iteration_setup, global_size, local_size); if(task->get_cancel()) { canceled = true; break; } } /* Read ray-state into Host memory to decide if we should exit * path-iteration in host. */ ciErr = clEnqueueReadBuffer(cqCommandQueue, ray_state, CL_TRUE, 0, global_size[0] * global_size[1] * sizeof(char), hostRayStateArray, 0, NULL, NULL); assert(ciErr == CL_SUCCESS); activeRaysAvailable = false; for(int rayStateIter = 0; rayStateIter < global_size[0] * global_size[1]; ++rayStateIter) { if(int8_t(hostRayStateArray[rayStateIter]) != RAY_INACTIVE) { /* Not all rays are RAY_INACTIVE. */ activeRaysAvailable = true; break; } } if(activeRaysAvailable) { numHostIntervention++; PathIteration_times = PATH_ITER_INC_FACTOR; /* Host intervention done before all rays become RAY_INACTIVE; * Set do more initial iterations for the next tile. */ numNextPathIterTimes += PATH_ITER_INC_FACTOR; } if(task->get_cancel()) { canceled = true; break; } } /* Execute SumALLRadiance kernel to accumulate radiance calculated in * per_sample_output_buffers into RenderTile's output buffer. */ if(!canceled) { size_t sum_all_radiance_local_size[2] = {16, 16}; size_t sum_all_radiance_global_size[2]; sum_all_radiance_global_size[0] = (((d_w - 1) / sum_all_radiance_local_size[0]) + 1) * sum_all_radiance_local_size[0]; sum_all_radiance_global_size[1] = (((d_h - 1) / sum_all_radiance_local_size[1]) + 1) * sum_all_radiance_local_size[1]; ENQUEUE_SPLIT_KERNEL(sum_all_radiance, sum_all_radiance_global_size, sum_all_radiance_local_size); } #undef ENQUEUE_SPLIT_KERNEL #undef GLUE if(numHostIntervention == 0) { /* This means that we are executing kernel more than required * Must avoid this for the next sample/tile. */ PathIteration_times = ((numNextPathIterTimes - PATH_ITER_INC_FACTOR) <= 0) ? PATH_ITER_INC_FACTOR : numNextPathIterTimes - PATH_ITER_INC_FACTOR; } else { /* Number of path-iterations done for this tile is set as * Initial path-iteration times for the next tile */ PathIteration_times = numNextPathIterTimes; } first_tile = false; }
void put(int i, int j, int k, double d) { *int8_p(data(i, j, k)) = int8_t(clamp(d) * INT8_MAX); }
void DisassemblerCore::DisassembleFunctionBlob(size_t blobEnd) { const size_t functionNameIndex = ReadValue16().mUShort; mOutStream.Print("Function: "); DisassembleSizeAndType(); mOutStream.Print(" "); mQualifiedNameTable[functionNameIndex].PrintTo(mOutStream); mOutStream.Print("("); DisassembleParamListSignature(); mOutStream.Print(")\n"); const uint32_t argSize = ReadValue32().mUInt; const uint32_t packedArgSize = ReadValue32().mUInt; const uint32_t localSize = ReadValue32().mUInt; const uint32_t stackSize = ReadValue32().mUInt; const uint32_t framePointerAlignment = ReadValue32().mUInt; const uint32_t codeSize = ReadValue32().mUInt; const size_t codeStart = GetPosition(); const size_t codeEnd = codeStart + codeSize; mOutStream.Print( "\targ size: %" BOND_PRIu32 "\n" "\tpacked arg size: %" BOND_PRIu32 "\n" "\tlocal size: %" BOND_PRIu32 "\n" "\tstack size: %" BOND_PRIu32 "\n" "\tframe pointer alignment: %" BOND_PRIu32 "\n" "\tcode size: %" BOND_PRIu32 "\n", argSize, packedArgSize, localSize, stackSize, framePointerAlignment, codeSize); while (GetPosition() < codeEnd) { const uint32_t opCodeAddress = uint32_t(GetPosition() - codeStart); const OpCode opCode = static_cast<OpCode>(mCboStream.Read()); const OpCodeParam param = GetOpCodeParamType(opCode); mOutStream.Print("%6" BOND_PRIu32 ": %-12s", opCodeAddress, GetOpCodeMnemonic(opCode)); switch (param) { case OC_PARAM_NONE: break; case OC_PARAM_CHAR: mOutStream.Print("%" BOND_PRId32, int32_t(int8_t(mCboStream.Read()))); break; case OC_PARAM_UCHAR: mOutStream.Print("%" BOND_PRIu32, uint32_t(mCboStream.Read())); break; case OC_PARAM_UCHAR_CHAR: mOutStream.Print("%" BOND_PRIu32 ", %" BOND_PRId32, uint32_t(mCboStream.Read()), int32_t(int8_t(mCboStream.Read()))); break; case OC_PARAM_SHORT: mOutStream.Print("%" BOND_PRId32, int32_t(ReadValue16().mShort)); break; case OC_PARAM_USHORT: mOutStream.Print("%" BOND_PRId32, uint32_t(ReadValue16().mUShort)); break; case OC_PARAM_INT: { const size_t valueIndex = ReadValue16().mUShort; const int32_t value = mValue32Table[valueIndex].mInt; mOutStream.Print("%" BOND_PRId32, value); } break; case OC_PARAM_VAL32: { const size_t valueIndex = ReadValue16().mUShort; const uint32_t value = mValue32Table[valueIndex].mUInt; mOutStream.Print("0x%" BOND_PRIx32, value); } break; case OC_PARAM_VAL64: { const size_t valueIndex = ReadValue16().mUShort; const uint64_t value = mValue64Table[valueIndex].mULong; mOutStream.Print("0x%" BOND_PRIx64, value); } break; case OC_PARAM_OFF16: { const int32_t offset = ReadValue16().mShort; const uint32_t baseAddress = uint32_t(GetPosition() - codeStart); mOutStream.Print("%" BOND_PRId32 " (%" BOND_PRIu32 ")", offset, baseAddress + offset); } break; case OC_PARAM_OFF32: { const size_t offsetIndex = ReadValue16().mUShort; const int32_t offset = mValue32Table[offsetIndex].mInt; const uint32_t baseAddress = uint32_t(GetPosition() - codeStart); mOutStream.Print("%" BOND_PRId32 " (%" BOND_PRIu32 ")", offset, baseAddress + offset); } break; case OC_PARAM_STRING: { const size_t stringIndex = ReadValue16().mUShort; WriteAbbreviatedString(mStringTable[stringIndex]); } break; case OC_PARAM_NAME: { const size_t nameIndex = ReadValue16().mUShort; mQualifiedNameTable[nameIndex].PrintTo(mOutStream); } break; case OC_PARAM_LOOKUPSWITCH: { Skip(AlignUpDelta(GetPosition() - codeStart, sizeof(Value32))); const int32_t defaultOffset = ReadValue32().mInt; const uint32_t numMatches = ReadValue32().mUInt; const size_t tableSize = numMatches * 2 * sizeof(Value32); const int32_t baseAddress = int32_t(GetPosition() + tableSize - codeStart); mOutStream.Print("\n%16s: %" BOND_PRId32 " (%" BOND_PRIu32 ")", "default", defaultOffset, baseAddress + defaultOffset); for (uint32_t i = 0; i < numMatches; ++i) { const int32_t match = ReadValue32().mInt; const int32_t offset = ReadValue32().mInt; mOutStream.Print("\n%16" BOND_PRId32 ": %" BOND_PRId32 " (%" BOND_PRIu32 ")", match, offset, baseAddress + offset); } } break; case OC_PARAM_TABLESWITCH: { Skip(AlignUpDelta(GetPosition() - codeStart, sizeof(Value32))); const int32_t defaultOffset = ReadValue32().mInt; const int32_t minMatch = ReadValue32().mInt; const int32_t maxMatch = ReadValue32().mInt; const uint32_t numMatches = maxMatch - minMatch + 1; const size_t tableSize = numMatches * sizeof(Value32); const int32_t baseAddress = int32_t(GetPosition() + tableSize - codeStart); mOutStream.Print("\n%16s: %" BOND_PRId32 " (%" BOND_PRIu32 ")", "default", defaultOffset, baseAddress + defaultOffset); for (uint32_t i = 0; i < numMatches; ++i) { const int32_t match = minMatch + i; const int32_t offset = ReadValue32().mInt; mOutStream.Print("\n%16" BOND_PRId32 ": %" BOND_PRId32 " (%" BOND_PRIu32 ")", match, offset, baseAddress + offset); } } break; } mOutStream.Print("\n"); } // Disassemble the optional metadata blob. if (GetPosition() < blobEnd) { DisassembleBlob(); } }
int main() { int16_t x[iSampleCount], coef[iSampleCount], tmp[iSampleCount], y[iSampleCount]; int i; // Makes a fancy cubic signal //for (i=0;i<32;i++) x[i]=i; //5+i+0.4*i*i-0.02*i*i*i; // random noise with gaussian filter srand(0); for (i=0;i<iSampleCount;i++) x[i] = int8_t(rand()); //x[iSampleCount-2] = 127; //x[iSampleCount-1] = 127; //for (i=0;i<(iSampleCount-1);i++) x[i] = (x[i] + x[i+1])/2; //for(i=0; i<(iSampleCount*1/3); i++) x[i] = 255; //for(i=0; i<(iSampleCount*3/3); i++) x[i] = 0; //for(; i<(iSampleCount*3/3); i++) x[i] = 255; //x[0] = 255; // Prints original sigal x printf("Original signal:\n"); //for (i=0;i<iSampleCount;i++) printf("x[%d]=%d\n",i,x[i]); printf("\n"); // Do the forward 5/3 transform fwt53(tmp, x, iSampleCount); //int iPassSample = iSampleCount; //int iLoopCount = 0; //memcpy(coef, x, iPassSample); //while(iPassSample>=4) //{ // fwt53(tmp, coef, iPassSample); // memcpy(coef, tmp, iSampleCount); // iPassSample>>=1; // iLoopCount++; //} // Prints the wavelet coefficients printf("Wavelets coefficients:\n"); //for (i=0;i<iSampleCount;i++) printf("wc[%d]=%d\n",i,coef[i]); printf("\n"); // Do the inverse 5/3 transform iwt53(y,tmp,iSampleCount); /*memcpy(tmp, coef, iSampleCount); while(iLoopCount) { iPassSample = iSampleCount; for(int i=0; i<iLoopCount; i++) { iPassSample >>= 1; } iwt53(y, tmp, iPassSample); memcpy(tmp, y, iSampleCount); iLoopCount --; }*/ // Prints the reconstructed signal int iError = 0; int iBias = 0; int iBiasLowFactors = 0; int iBiasHighFactors = 0; int iErrorMax = 0; int iErrorMaxIndex = 0; printf("Reconstructed signal:\n"); for (i=0;i<iSampleCount;i++) { int iAvg = tmp[i/2]; int iDelta = tmp[i/2+(iSampleCount/2)]; iError += std::abs(y[i]-x[i]); iBias += (y[i] - x[i]); if(std::abs(y[i]-x[i]) > 10) { if(i%2) printf("xx[%d]= (%3d => %3d => %3d)\n",i,x[i], iDelta, y[i]); else printf("xx[%d]= (%3d => [%3d] => %3d)\n",i,x[i], iAvg, y[i]); } if(i%2) { iBiasHighFactors += (y[i] - x[i]); } else { iBiasLowFactors += (y[i] - x[i]); } if(std::abs(y[i]-x[i]) > iErrorMax) { iErrorMax = std::abs(y[i]-x[i]); iErrorMaxIndex = i; } } printf("Error: %f (Max:%d[%d : %d=>%d])\n", float(iError)/iSampleCount, iErrorMax, iErrorMaxIndex, x[iErrorMaxIndex], y[iErrorMaxIndex]); printf("Bias: %f (Low:%f / High:%f)\n" ,float(iBias)/iSampleCount ,float(iBiasLowFactors)/(iSampleCount/2) ,float(iBiasHighFactors)/(iSampleCount/2)); //calculer l'err max! }
static size_t encoded_iva_size(uint8_t lowByte) { // High order bit set => 4-byte. return int8_t(lowByte) >= 0 ? 1 : 4; }
// Create a RBDL model from URDF xml string uint32_t VigirRobotRBDLModel::loadRobotModel(const std::string xml, const double& mass_factor, const bool& verbose) { // We are assuming humanoid form factor and looking for four end effector names std::cout << " Initialize robot with:" << std::endl; std::cout << lhand_link_name_ << " " << rhand_link_name_ << std::endl; std::cout << " " << root_link_name_ << std::endl; std::cout << lfoot_link_name_ << " " << rfoot_link_name_ << std::endl; std::cout << " Calling urdf model initString ..." << std::endl; boost::shared_ptr<urdf::Model> urdf_model_ptr(new urdf::Model()); bool rc = urdf_model_ptr->initString(xml); if (!rc) { std::cout << "Failed to load robot model in urdf" << std::endl; std::cerr << "Error: Failed to load robot model in urdf" << std::endl; return 1; } std::cout << " Pre-process URDF links by applying mass factor and checking for non-zero rotations in link body" << std::endl; URDFLinkMap urdf_link_map; urdf_link_map = urdf_model_ptr->links_; double total_mass = 0.0; int count = 0; vigir_control::Vector3d rpy; for(URDFLinkMap::const_iterator lm_itr = urdf_link_map.begin(); lm_itr != urdf_link_map.end(); ++lm_itr) { if (lm_itr->second->inertial) { //printf("Link(% 3d) %s original mass=%f \n",count, lm_itr->second->name.c_str(), lm_itr->second->inertial->mass); lm_itr->second->inertial->mass *= mass_factor; total_mass += lm_itr->second->inertial->mass; lm_itr->second->inertial->origin.rotation.getRPY (rpy[0], rpy[1], rpy[2]); if (rpy != vigir_control::Vector3d(0.0, 0.0, 0.0)) { std::cerr << "Error while processing body '" << lm_itr->second->name << "': rotation of body frames " << rpy.transpose() << " not yet supported. Please rotate the joint frame instead. " << std::endl; if (lm_itr->second->inertial->mass > 1e-4) { std::cerr << " Significant mass=" << lm_itr->second->inertial->mass << " - but override rotation anyway!" << std::endl; } lm_itr->second->inertial->origin.rotation.setFromRPY(0.0,0.0,0.0); } } //else //{ // printf("Link(% 3d) %s Non-inertial \n",count, lm_itr->second->name.c_str()); //} ++count; } printf(" Total links =%d adjusted total mass = %f\n\n",count, total_mass); std::cout << " Pre-process URDF joints by FIXing non-controlled joints" << std::endl; URDFJointMap urdf_joint_map; urdf_joint_map = urdf_model_ptr->joints_; for(URDFJointMap::const_iterator jm_itr = urdf_joint_map.begin(); jm_itr != urdf_joint_map.end(); ++jm_itr) { try { joint_map_.at(jm_itr->first); // looking for existance in map } catch(...) { if (jm_itr->second->type != urdf::Joint::FIXED) { printf("Set uncontrolled joint %s (%s) to FIXED type (%d) instead of %d\n", jm_itr->first.c_str(), jm_itr->second->name.c_str(), urdf::Joint::FIXED, jm_itr->second->type); jm_itr->second->type = urdf::Joint::FIXED; } } } std::cout << "Construct the RBDL model from the adjusted urdf model ..." << std::endl; if (!RigidBodyDynamics::Addons::construct_model(&(my_rbdl_->rbdl_model_), urdf_model_ptr, verbose)) { std::cout << "Failed to load robot model into RBDL format !"<< std::endl; std::cerr << "Failed to load robot model into RBDL format !"<< std::endl; return 2; } std::cout << "Done RBDL model construction!" << std::endl; printf(" List of all robot body parts (%d fixed, %d movable, %d DOF, %d joints):\n", uint8_t(my_rbdl_->rbdl_model_.mFixedBodies.size()), uint8_t(my_rbdl_->rbdl_model_.mBodies.size()), my_rbdl_->rbdl_model_.dof_count,uint8_t(my_rbdl_->rbdl_model_.mJoints.size())); printf("Note: fixed bodies are already joined to moveable parents\n"); double total_mass2= 0.0; for (int ndx = 0; ndx < int8_t(my_rbdl_->rbdl_model_.mBodies.size()); ++ndx) { if ( rfoot_link_name_ == my_rbdl_->rbdl_model_.GetBodyName(ndx)) { r_foot_id_ = ndx; printf(" Found end effector %s at %d\n", my_rbdl_->rbdl_model_.GetBodyName(ndx).c_str(),ndx); } else if ( lfoot_link_name_ == my_rbdl_->rbdl_model_.GetBodyName(ndx)) { l_foot_id_ = ndx; printf(" Found end effector %s at %d\n", my_rbdl_->rbdl_model_.GetBodyName(ndx).c_str(),ndx); } else if ( rhand_link_name_ == my_rbdl_->rbdl_model_.GetBodyName(ndx)) { r_hand_id_ = ndx; printf(" Found end effector %s at %d\n", my_rbdl_->rbdl_model_.GetBodyName(ndx).c_str(),ndx); } else if ( lhand_link_name_ == my_rbdl_->rbdl_model_.GetBodyName(ndx)) { l_hand_id_ = ndx; printf(" Found end effector %s at %d\n", my_rbdl_->rbdl_model_.GetBodyName(ndx).c_str(),ndx); } total_mass2 += my_rbdl_->rbdl_model_.mBodies[ndx].mMass; printf("Body : % 3d :%s : mass=%f\n", ndx, my_rbdl_->rbdl_model_.GetBodyName(ndx).c_str(), my_rbdl_->rbdl_model_.mBodies[ndx].mMass); } printf(" Total mass=%f = %f\n\n",total_mass, total_mass2); if (( r_foot_id_ < 1) || ( l_foot_id_ < 1) || (r_hand_id_ < 1) || (l_hand_id_ < 1)) { printf(" Failed to find all end effectors feet(%d, %d) hands (%d, %d)\n", l_foot_id_, r_foot_id_, l_hand_id_, r_hand_id_); return 3; } // Maps from one to another representation rbdl_to_ctrl_joint.resize(my_rbdl_->rbdl_model_.mJoints.size(),-1); ctrl_to_rbdl_joint.resize(n_joints_); printf(" %10s : %10s :%s :%s\n", "Joint Name", "Child Link", "Control", "RBDL"); for(std::map<std::string, int8_t>::const_iterator jm_itr = joint_map_.begin(); jm_itr != joint_map_.end(); ++jm_itr) { std::string jnt_name = jm_itr->first; // controlled joint name int8_t jnt_ndx = jm_itr->second; // index into controlled joint list try { JointPtr urdf_joint = urdf_joint_map.at(jnt_name); // URDF map int body_ndx = my_rbdl_->rbdl_model_.GetBodyId(urdf_joint->child_link_name.c_str()); if (my_rbdl_->rbdl_model_.IsBodyId(body_ndx)) { rbdl_to_ctrl_joint[body_ndx] = jnt_ndx; // maps body index to the controlled joint that moves the body ctrl_to_rbdl_joint[jnt_ndx] = body_ndx-1; // maps controlled joint to the Q vector index (not what documentation says!) printf(" %10s : %10s : % 3d : % 3d\n", jnt_name.c_str(), urdf_joint->child_link_name.c_str(), jnt_ndx, body_ndx); } else { printf("Could not find body for joint <%s> - child <%s>",jnt_name.c_str(), urdf_joint->child_link_name.c_str()); return 4; } } catch(...) { std::cout << "Could not find controlled joint <" << jnt_name << " in URDF " << std::endl; return 5; } } for (uint ndx = 0; ndx < rbdl_to_ctrl_joint.size(); ++ndx) { printf("RBDL body: %s ctrl ndx=%d\n",my_rbdl_->rbdl_model_.GetBodyName(ndx).c_str(), rbdl_to_ctrl_joint[ndx]); } for (uint ndx = 0; ndx < ctrl_to_rbdl_joint.size(); ++ndx) { printf("Controlled link: %d rbdl ndx=%d\n",ndx, ctrl_to_rbdl_joint[ndx]); } // Assume model in upright pose my_rbdl_->rbdl_model_.gravity.set (0., 0., -9.81); // Initialize the vectors for storing robot state my_rbdl_->Q_ = RigidBodyDynamics::Math::VectorNd::Constant ((size_t)my_rbdl_->rbdl_model_.dof_count,0.0); // contra documentation, Q[0] is first joint my_rbdl_->QDot_ = RigidBodyDynamics::Math::VectorNd::Constant ((size_t)my_rbdl_->rbdl_model_.dof_count,0.0); my_rbdl_->QDDot_ = RigidBodyDynamics::Math::VectorNd::Constant ((size_t)my_rbdl_->rbdl_model_.dof_count,0.0); // set to zero for now my_rbdl_->tau_ = RigidBodyDynamics::Math::VectorNd::Constant ((size_t)my_rbdl_->rbdl_model_.dof_count,0.0); // generalized forces std::cout << " Done loading RBDL model with "<< my_rbdl_->rbdl_model_.dof_count << " DOF! "<< std::endl << std::endl; return 0; }
//--------------------------------------------------------------------------------------- int tNdp2kTableDataSources::SetTableData( unsigned row, unsigned col, eSetType setType, const void* pSetData, unsigned dataSize ) { if (col != TABLE_COL_ALL) return TABLE_ERROR_INVALID_ARGUMENT; if (pSetData == NULL) { if (setType < SetType_MultiStart) return TABLE_ERROR_INVALID_ARGUMENT; int result = TABLE_OK; if (setType == SetType_MultiEnd) { // as breakdown is always by row, SetType_MultiEnd can only occur for full table transfers tTableFormat format = GetFormat(); if (dataSize > format) SetFormat( tTableFormat(dataSize) ); else if (dataSize < format) result = TABLE_OK_OLDER_FORMAT; emit TableChanged(); } return result; } if (row >= unsigned(m_cMaxRows)) return TABLE_ERROR_INVALID_ROW; Assert( DATA_ENGINE_ENUM_MIN >= -127 && DATA_ENGINE_ENUM_MAX <= 127 ); tSourceSelections selections; tDecoder data( pSetData, dataSize ); uint8_t count; if (data.GetFixed( count ) < 0) return data.Result(); if (count == 0 || --count >= m_cMaxInstances) return TABLE_ERROR_CORRUPT_DATA; uint16_t type; if (data.GetFixed( type ) < 0) return data.Result(); tDataType dataType = tDataType( type ); selections.reserve( count ); for (int i = 0; i < count; ++i) { const void* pColData; int size = data.GetSized( pColData ); if (size < 0) return data.Result(); if (size > 127) return TABLE_ERROR_CORRUPT_DATA; if (size == 0) { selections << tDataId(); } else { const uint8_t* pData = static_cast< const uint8_t* >( pColData ); selections << tDataId( dataType, tDataId::tDataSource( uint8_t(size-1), pData+1 ), tDataEngineType( int8_t(*pData) ) ); } } if (data.Remaining() != 0) return TABLE_ERROR_CORRUPT_DATA; bool changed = false; { tQMutexLocker locker( &m_Lock ); if (row >= unsigned(m_Table.count())) { if (setType != SetType_Table) return TABLE_ERROR_NEWER_FORMAT; if (row != unsigned(m_Table.count())) return TABLE_ERROR_MISSING_ROW; m_Table.resize( m_Table.count()+1 ); m_Table[ row ].dataType = dataType; } else if (dataType != m_Table[ row ].dataType) { // Assert( 0 ); return TABLE_ERROR_CORRUPT_DATA; } m_Table[ row ].dirty = false; if (selections != m_Table[ row ].selections) { m_Table[ row ].selections = selections; changed = true; } } if (changed == true && setType != SetType_Table) emit RowChanged( row ); return TABLE_OK; }
// set the state of the ATN line (false: low, true: high) inline void setATN(bool newState) { atnState = uint8_t(-(int8_t(newState))); }
RowSetPtr Executor::executeResultPlan(const Planner::Result* result_plan, const bool hoist_literals, const ExecutorDeviceType device_type, const ExecutorOptLevel opt_level, const Catalog_Namespace::Catalog& cat, size_t& max_groups_buffer_entry_guess, int32_t* error_code, const Planner::Sort* sort_plan, const bool allow_multifrag, const bool just_explain, const bool allow_loop_joins) { const auto agg_plan = dynamic_cast<const Planner::AggPlan*>(result_plan->get_child_plan()); if (!agg_plan) { // TODO(alex) throw std::runtime_error("Query not supported yet, child plan needs to be an aggregate plan."); } row_set_mem_owner_ = std::make_shared<RowSetMemoryOwner>(); lit_str_dict_proxy_ = nullptr; const auto scan_plan = dynamic_cast<const Planner::Scan*>(agg_plan->get_child_plan()); auto simple_quals = scan_plan ? scan_plan->get_simple_quals() : std::list<std::shared_ptr<Analyzer::Expr>>{}; auto quals = scan_plan ? scan_plan->get_quals() : std::list<std::shared_ptr<Analyzer::Expr>>{}; std::vector<InputDescriptor> input_descs; std::list<std::shared_ptr<const InputColDescriptor>> input_col_descs; collect_input_descs(input_descs, input_col_descs, agg_plan, cat); const auto join_plan = get_join_child(agg_plan); if (join_plan) { collect_quals_from_join(simple_quals, quals, join_plan); } const auto join_quals = join_plan ? join_plan->get_quals() : std::list<std::shared_ptr<Analyzer::Expr>>{}; CHECK(check_plan_sanity(agg_plan)); const auto query_infos = get_table_infos(input_descs, this); const auto ra_exe_unit_in = RelAlgExecutionUnit{input_descs, {}, input_col_descs, simple_quals, quals, JoinType::INVALID, {}, join_quals, {}, agg_plan->get_groupby_list(), get_agg_target_exprs(agg_plan), {}, nullptr, {{}, SortAlgorithm::Default, 0, 0}, 0}; QueryRewriter query_rewriter(ra_exe_unit_in, query_infos, this, result_plan); const auto ra_exe_unit = query_rewriter.rewrite(); auto result = executeWorkUnit(error_code, max_groups_buffer_entry_guess, true, query_infos, ra_exe_unit, {device_type, hoist_literals, opt_level, g_enable_dynamic_watchdog}, {false, allow_multifrag, just_explain, allow_loop_joins, g_enable_watchdog, false, false, g_enable_dynamic_watchdog, g_dynamic_watchdog_time_limit}, cat, row_set_mem_owner_, nullptr, true); auto& rows = boost::get<RowSetPtr>(result); CHECK(rows); if (just_explain) { return std::move(rows); } const int in_col_count{static_cast<int>(agg_plan->get_targetlist().size())}; std::list<std::shared_ptr<const InputColDescriptor>> pseudo_input_col_descs; for (int pseudo_col = 1; pseudo_col <= in_col_count; ++pseudo_col) { pseudo_input_col_descs.push_back(std::make_shared<const InputColDescriptor>(pseudo_col, 0, -1)); } const auto order_entries = sort_plan ? sort_plan->get_order_entries() : std::list<Analyzer::OrderEntry>{}; const RelAlgExecutionUnit res_ra_unit{{}, {}, pseudo_input_col_descs, result_plan->get_constquals(), result_plan->get_quals(), JoinType::INVALID, {}, {}, {}, {nullptr}, get_agg_target_exprs(result_plan), {}, nullptr, { order_entries, SortAlgorithm::Default, 0, 0, }, 0}; if (*error_code) { return std::make_shared<ResultSet>( std::vector<TargetInfo>{}, ExecutorDeviceType::CPU, QueryMemoryDescriptor{}, nullptr, this); } const auto& targets = result_plan->get_targetlist(); CHECK(!targets.empty()); std::vector<AggInfo> agg_infos; for (size_t target_idx = 0; target_idx < targets.size(); ++target_idx) { const auto target_entry = targets[target_idx]; const auto target_type = target_entry->get_expr()->get_type_info().get_type(); agg_infos.emplace_back((target_type == kFLOAT || target_type == kDOUBLE) ? "agg_id_double" : "agg_id", target_entry->get_expr(), 0, target_idx); } std::vector<SQLTypeInfo> target_types; for (auto in_col : agg_plan->get_targetlist()) { target_types.push_back(in_col->get_expr()->get_type_info()); } CHECK(rows); ColumnarResults result_columns(row_set_mem_owner_, *rows, in_col_count, target_types); std::vector<llvm::Value*> col_heads; // Nested query, let the compiler know ResetIsNested reset_is_nested(this); is_nested_ = true; std::vector<Analyzer::Expr*> target_exprs; for (auto target_entry : targets) { target_exprs.emplace_back(target_entry->get_expr()); } const auto row_count = rows->rowCount(); if (!row_count) { return std::make_shared<ResultSet>( std::vector<TargetInfo>{}, ExecutorDeviceType::CPU, QueryMemoryDescriptor{}, nullptr, this); } std::vector<ColWidths> agg_col_widths; for (auto wid : get_col_byte_widths(target_exprs, {})) { agg_col_widths.push_back( {wid, int8_t(compact_byte_width(wid, pick_target_compact_width(res_ra_unit, {}, get_min_byte_width())))}); } QueryMemoryDescriptor query_mem_desc{this, allow_multifrag, GroupByColRangeType::Projection, false, false, -1, 0, {sizeof(int64_t)}, #ifdef ENABLE_KEY_COMPACTION 0, #endif agg_col_widths, {}, row_count, small_groups_buffer_entry_count_, 0, 0, 0, false, GroupByMemSharing::Shared, CountDistinctDescriptors{}, false, true, false, false, {}, {}, false}; auto compilation_result = compileWorkUnit(false, {}, res_ra_unit, {ExecutorDeviceType::CPU, hoist_literals, opt_level, g_enable_dynamic_watchdog}, {false, allow_multifrag, just_explain, allow_loop_joins, g_enable_watchdog, false, false, g_enable_dynamic_watchdog, g_dynamic_watchdog_time_limit}, nullptr, false, row_set_mem_owner_, row_count, small_groups_buffer_entry_count_, get_min_byte_width(), JoinInfo(JoinImplType::Invalid, std::vector<std::shared_ptr<Analyzer::BinOper>>{}, {}, ""), false); auto column_buffers = result_columns.getColumnBuffers(); CHECK_EQ(column_buffers.size(), static_cast<size_t>(in_col_count)); std::vector<int64_t> init_agg_vals(query_mem_desc.agg_col_widths.size()); auto query_exe_context = query_mem_desc.getQueryExecutionContext(res_ra_unit, init_agg_vals, this, ExecutorDeviceType::CPU, 0, {}, {}, {}, row_set_mem_owner_, false, false, nullptr); const auto hoist_buf = serializeLiterals(compilation_result.literal_values, 0); *error_code = 0; std::vector<std::vector<const int8_t*>> multi_frag_col_buffers{column_buffers}; query_exe_context->launchCpuCode(res_ra_unit, compilation_result.native_functions, hoist_literals, hoist_buf, multi_frag_col_buffers, {{static_cast<int64_t>(result_columns.size())}}, {{0}}, 1u, 0, init_agg_vals, error_code, 1, {}); CHECK_GE(*error_code, 0); return query_exe_context->groupBufferToResults(0, target_exprs, false); }