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);
}
