void GenerateFullMatrices(double values[], double scale,
boost::shared_ptr<NekMatrix<NekDouble, StandardMatrixTag> >& m1,
boost::shared_ptr<NekMatrix<NekMatrix<NekDouble>, ScaledMatrixTag> >& m2,
boost::shared_ptr<NekMatrix<NekMatrix<NekDouble>, BlockMatrixTag> >& m3)
{
m1 = MakePtr(new NekMatrix<NekDouble, StandardMatrixTag>(4, 4, values));
double inner_values[16];
std::transform(values, values+16, inner_values, boost::bind(std::divides<NekDouble>(), _1, scale));
boost::shared_ptr<NekMatrix<NekDouble> > inner(
new NekMatrix<NekDouble>(4, 4, inner_values));
m2 = MakePtr(new NekMatrix<NekMatrix<NekDouble>, ScaledMatrixTag>(scale, inner));
double block_1_values[] = {values[0], values[1],
values[4], values[5]};
double block_2_values[] = {values[2], values[3],
values[6], values[7]};
double block_3_values[] = {values[8], values[9],
values[12], values[13]};
double block_4_values[] = {values[10], values[11],
values[14], values[15]};
boost::shared_ptr<NekMatrix<NekDouble> > block1(new NekMatrix<NekDouble>(2, 2, block_1_values));
boost::shared_ptr<NekMatrix<NekDouble> > block2(new NekMatrix<NekDouble>(2, 2, block_2_values));
boost::shared_ptr<NekMatrix<NekDouble> > block3(new NekMatrix<NekDouble>(2, 2, block_3_values));
boost::shared_ptr<NekMatrix<NekDouble> > block4(new NekMatrix<NekDouble>(2, 2, block_4_values));
m3 = MakePtr(new NekMatrix<NekMatrix<NekDouble>, BlockMatrixTag>(2, 2, 2, 2));
m3->SetBlock(0,0, block1);
m3->SetBlock(1,0, block2);
m3->SetBlock(0,1, block3);
m3->SetBlock(1,1, block4);
}
void OnlineSession::updateAccess(string filename, double& diskTime){
b_index_t blockIndices[SIZE_MIN];
prSubset.get(blockIndices, SIZE_MIN);
byte firstBlock[BLOCK_SIZE*2];
clock_t start = clock();
readD(blockIndices, 2, firstBlock);
diskTime += (double)(clock()-start)/CLOCKS_PER_SEC;
DataBlock block(blockIndices[0]);
block.parse(firstBlock);
blocks.push_back(block);
DataBlock block1(blockIndices[1]);
block.parse(firstBlock+BLOCK_SIZE);
blocks.push_back(block1);
size_t filesize = *(size_t*)(&firstBlock);
int lastBlock = (b_index_t)(ceil((double)filesize/(double)MAX_BLOCK_DATA_SIZE))+1;
b_index_t blockIndicesComplete[prSubset.getSize()];
prSubset.get(blockIndicesComplete, prSubset.getSize());
blocks[1].update(fid, firstBlock, MAX_BLOCK_DATA_SIZE);
byte blockToWrite[BLOCK_SIZE];
blocks[1].getEncrypted(blockToWrite);
// DataBlock lblock(blockIndicesComplete[lastBlock-1]);
fileBlocks.push_back(block1);
}
void GenerateUpperTriangularMatrices(NekDouble values[], NekDouble scale,
boost::shared_ptr<NekMatrix<NekDouble, StandardMatrixTag> >& m1,
boost::shared_ptr<NekMatrix<NekMatrix<NekDouble>, ScaledMatrixTag> >& m2,
boost::shared_ptr<NekMatrix<NekMatrix<NekDouble>, BlockMatrixTag> >& m3)
{
m1 = MakePtr(new NekMatrix<NekDouble, StandardMatrixTag>(4, 4, values, eUPPER_TRIANGULAR));
double inner_values[10];
std::transform(values, values+10, inner_values, boost::bind(std::divides<NekDouble>(), _1, scale));
boost::shared_ptr<NekMatrix<NekDouble> > inner(
new NekMatrix<NekDouble>(4, 4, inner_values, eUPPER_TRIANGULAR));
m2 = MakePtr(new NekMatrix<NekMatrix<NekDouble>, ScaledMatrixTag>(scale, inner));
double block_1_values[] = {values[0], 0.0,
values[1], values[2]};
double block_2_values[] = {values[3], values[4],
values[6], values[7]};
double block_4_values[] = {values[5], 0.0,
values[8], values[9]};
boost::shared_ptr<NekMatrix<NekDouble> > block1(new NekMatrix<NekDouble>(2, 2, block_1_values));
boost::shared_ptr<NekMatrix<NekDouble> > block2(new NekMatrix<NekDouble>(2, 2, block_2_values));
boost::shared_ptr<NekMatrix<NekDouble> > block4(new NekMatrix<NekDouble>(2, 2, block_4_values));
m3 = MakePtr(new NekMatrix<NekMatrix<NekDouble>, BlockMatrixTag>(2, 2, 2, 2));
m3->SetBlock(0,0, block1);
m3->SetBlock(0,1, block2);
m3->SetBlock(1,1, block4);
}
std::list<Point> medianCut(Point* image, int numPoints, unsigned int desiredSize)
{
std::priority_queue<Block> blockQueue;
Block initialBlock(image, numPoints);
initialBlock.shrink();
blockQueue.push(initialBlock);
while (blockQueue.size() < desiredSize)
{
Block longestBlock = blockQueue.top();
blockQueue.pop();
Point * begin = longestBlock.getPoints();
Point * median = longestBlock.getPoints() + (longestBlock.numPoints()+1)/2;
Point * end = longestBlock.getPoints() + longestBlock.numPoints();
switch(longestBlock.longestSideIndex())
{
case 0: std::nth_element(begin, median, end, CoordinatePointComparator<0>()); break;
case 1: std::nth_element(begin, median, end, CoordinatePointComparator<1>()); break;
case 2: std::nth_element(begin, median, end, CoordinatePointComparator<2>()); break;
}
Block block1(begin, median-begin), block2(median, end-median);
block1.shrink();
block2.shrink();
blockQueue.push(block1);
blockQueue.push(block2);
}
std::list<Point> result;
while(!blockQueue.empty())
{
Block block = blockQueue.top();
blockQueue.pop();
Point * points = block.getPoints();
int sum[NUM_DIMENSIONS] = {0};
for(int i=0; i < block.numPoints(); i++)
{
for(int j=0; j < NUM_DIMENSIONS; j++)
{
sum[j] += points[i].x[j];
}
}
Point averagePoint;
for(int j=0; j < NUM_DIMENSIONS; j++)
{
averagePoint.x[j] = sum[j] / block.numPoints();
}
result.push_back(averagePoint);
}
return result;
}
// メインプログラム
//
int main() {
// アプリウインドウの準備
AppEnv app_env(Window::WIDTH, Window::HEIGHT,
false, true);
Texture block1("res/block1.png");
//Texture bg1("res/");
int map_x = 0;
int map_y = 0;
int count = 0;
Vec2f map_num[MAP_Y*MAP_X];
for (map_y = MAP_Y - 1; map_y > -1 ;map_y--){
for (map_x = 0; map_x < MAP_X; map_x++)
{
map_num[count] = Vec2f(Pos_x(size * (map_x)), Pos_y(size * map_y));
count++;
}
}
while (1)
{
if (!app_env.isOpen())return(0);
app_env.setupDraw();
Vec2f mousepos = app_env.mousePosition();
for (map_y = 0; map_y < MAP_Y; map_y++){
for (map_x = 0; map_x < MAP_X; map_x++)
{
Draw2(map_num[(map_y*14)+map_x].x(), map_num[map_y*MAP_X+map_x].y());
}
}
//EnemyMove();
EnemyMove(map_num);
Draw();
drawFillBox(mousepos.x(), mousepos.y(), 20, 20, Color(1, 1, 1),0,Vec2f(1,1),Vec2f(10,10));
app_env.update();
}
// アプリ終了
}
TEST_F(ServerCollectTest, add)
{
srand(time(NULL));
DataServerStatInfo info;
memset(&info, 0, sizeof(info));
info.status_ = DATASERVER_STATUS_ALIVE;
info.id_ = 0xfffffff0;
time_t now = Func::get_monotonic_time();
BlockCollect block(100, now);
bool master = false;
bool writable = false;
ServerCollect server(layout_manager_, info, now);
EXPECT_EQ(EXIT_PARAMETER_ERROR, server.add(INVALID_BLOCK_ID, writable, master));
EXPECT_EQ(0, server.writable_->size());
EXPECT_EQ(0, server.hold_master_->size());
EXPECT_EQ(0, server.hold_->size());
EXPECT_EQ(TFS_SUCCESS, server.add(block.id(), writable, master));
EXPECT_EQ(0, server.writable_->size());
EXPECT_EQ(0, server.hold_master_->size());
EXPECT_EQ(1, server.hold_->size());
master = true;
writable = true;
server.hold_->clear();
EXPECT_EQ(TFS_SUCCESS, server.add(block.id(), writable, master));
EXPECT_EQ(1, server.writable_->size());
EXPECT_EQ(0, server.hold_master_->size());
EXPECT_EQ(1, server.hold_->size());
master = true;
writable = true;
server.hold_->clear();
server.writable_->clear();
BlockCollect block1(101, now);
EXPECT_EQ(TFS_SUCCESS, server.add(block.id(), writable, master));
EXPECT_EQ(1, server.writable_->size());
EXPECT_EQ(0, server.hold_master_->size());
EXPECT_EQ(1, server.hold_->size());
}
TEST_F(ServerCollectTest, add)
{
srand(time(NULL));
DataServerStatInfo info;
memset(&info, 0, sizeof(info));
info.status_ = DATASERVER_STATUS_ALIVE;
info.id_ = 0xfffffff0;
time_t now = Func::get_monotonic_time();
BlockCollect block(100, now);
bool master = false;
bool writable = false;
ServerCollect server(info, now);
EXPECT_FALSE(server.add(NULL, writable, master));
EXPECT_EQ(0, server.writable_->size());
EXPECT_EQ(0, server.hold_master_->size());
EXPECT_EQ(0, server.hold_->size());
EXPECT_TRUE(server.add(&block, writable, master));
EXPECT_EQ(0, server.writable_->size());
EXPECT_EQ(0, server.hold_master_->size());
EXPECT_EQ(1, server.hold_->size());
master = true;
writable = true;
server.hold_->clear();
EXPECT_TRUE(server.add(&block, writable, master));
EXPECT_EQ(1, server.writable_->size());
EXPECT_EQ(0, server.hold_master_->size());
EXPECT_EQ(1, server.hold_->size());
master = true;
writable = true;
server.hold_->clear();
server.writable_->clear();
BlockCollect block1(101, now);
EXPECT_TRUE(server.add(&block1, writable, master));
EXPECT_EQ(0, server.writable_->size());
EXPECT_EQ(0, server.hold_master_->size());
EXPECT_EQ(1, server.hold_->size());
}
void defense(void){
d_calibrateR();
Delay(500);
d_calibrateL();
Delay(500);
d_centre(steps_taken);
Delay(500);
block1();
Delay(500);
unblock1();
Delay(500);
block2();
Delay(500);
unblock2();
Delay(500);
return;
}
// Test the CacheBlock utility object Read() and LastAccessTick().
bool TestCacheBlock() {
uint32 offset = 13;
uint32 segment_id = 0;
uint32 block_size = file_bundle_size_ / 4;
CachedReadAccessor::CacheBlockAddress address1(segment_id, 0);
uint64 access_tick = 1033;
CachedReadAccessor::CacheBlock block1(address1, block_size);
// Check the initial access tick
TestAssert(block1.LastAccessTick() == 0);
block1.SetLastAccessTick(access_tick - 1);
TestAssert(block1.LastAccessTick() == (access_tick - 1));
// Test Read
// Read request that is contained in 1 block.
uint32 request_count = block_size - offset - 10;
FileBundleReaderSegment segment(file_pool_,
path_base_,
segment_names_[segment_id],
segment_names_[segment_id],
segment_id);
std::string buffer;
buffer.reserve(block_size);
buffer.resize(request_count);
char* out_buffer = const_cast<char*>(buffer.data());
// Test read within non-cached (uninitialized) block
uint64 stats_bytes_read = 0;
uint64 stats_disk_accesses = 0;
uint32 read_count =
block1.Read(segment, out_buffer, request_count, offset, access_tick++,
stats_bytes_read, stats_disk_accesses);
TestAssert(block1.LastAccessTick() + 1 == access_tick);
TestAssertEquals(stats_bytes_read, static_cast<uint64>(block_size));
TestAssertEquals(stats_disk_accesses, static_cast<uint64>(1));
TestAssertEquals(request_count, read_count);
char* expected = test_buffer_ + offset;
if (!TestBuffer(out_buffer, expected, read_count,
std::string("TestCacheBlock: all data in one non-cached block")))
return false;
// Test read from the NOW cached block within the segment.
offset = 23;
request_count /= 3;
buffer.resize(request_count);
read_count =
block1.Read(segment, out_buffer, request_count, offset, access_tick++,
stats_bytes_read, stats_disk_accesses);
TestAssertEquals(stats_bytes_read, static_cast<uint64>(block_size));
TestAssertEquals(stats_disk_accesses, static_cast<uint64>(1));
TestAssertEquals(request_count, read_count);
expected = test_buffer_ + offset;
if (!TestBuffer(out_buffer, expected, read_count,
std::string("TestCacheBlock: all data in one cached block")))
return false;
// Test a PARTIAL reads from a block (i.e., a request past the block
// boundary.
// create a new CacheBlock to start with an empty cache.
block1 = CachedReadAccessor::CacheBlock(address1, block_size);
request_count = 200;
buffer.resize(request_count);
uint32 expected_read_count = 133;
offset = block_size - expected_read_count;
// Read from a non-cached block
read_count =
block1.Read(segment, out_buffer, request_count, offset, access_tick++,
stats_bytes_read, stats_disk_accesses);
TestAssertEquals(stats_bytes_read, static_cast<uint64>(2*block_size));
TestAssertEquals(stats_disk_accesses, static_cast<uint64>(2));
TestAssertEquals(expected_read_count, read_count);
expected = test_buffer_ + offset;
if (!TestBuffer(out_buffer, expected, read_count,
std::string("TestCacheBlock: partial data in cached block")))
return false;
// Read from a cached block
read_count =
block1.Read(segment, out_buffer, request_count, offset, access_tick++,
stats_bytes_read, stats_disk_accesses);
TestAssertEquals(expected_read_count, read_count);
expected = test_buffer_ + offset;
if (!TestBuffer(out_buffer, expected, read_count,
std::string("TestCacheBlock: partial data in cached block")))
return false;
return true;
}
//from Kwalletbackend.
// this should be SHA-512 for release probably
QString Hash::password2hash(const QByteArray& password) {
SHA1 sha;
QByteArray hash;
hash.resize(20);
hash.fill(0);
int shasz = sha.size() / 8;
assert(shasz >= 20);
QByteArray block1(shasz, 0);
sha.process(password.data(), qMin(password.size(), 16));
// To make brute force take longer
for (int i = 0; i < 2000; i++) {
memcpy(block1.data(), sha.hash(), shasz);
sha.reset();
sha.process(block1.data(), shasz);
}
sha.reset();
if (password.size() > 16) {
sha.process(password.data() + 16, qMin(password.size() - 16, 16));
QByteArray block2(shasz, 0);
// To make brute force take longer
for (int i = 0; i < 2000; i++) {
memcpy(block2.data(), sha.hash(), shasz);
sha.reset();
sha.process(block2.data(), shasz);
}
sha.reset();
if (password.size() > 32) {
sha.process(password.data() + 32, qMin(password.size() - 32, 16));
QByteArray block3(shasz, 0);
// To make brute force take longer
for (int i = 0; i < 2000; i++) {
memcpy(block3.data(), sha.hash(), shasz);
sha.reset();
sha.process(block3.data(), shasz);
}
sha.reset();
if (password.size() > 48) {
sha.process(password.data() + 48, password.size() - 48);
QByteArray block4(shasz, 0);
// To make brute force take longer
for (int i = 0; i < 2000; i++) {
memcpy(block4.data(), sha.hash(), shasz);
sha.reset();
sha.process(block4.data(), shasz);
}
sha.reset();
// split 14/14/14/14
hash.resize(56);
memcpy(hash.data(), block1.data(), 14);
memcpy(hash.data() + 14, block2.data(), 14);
memcpy(hash.data() + 28, block3.data(), 14);
memcpy(hash.data() + 42, block4.data(), 14);
block4.fill(0);
} else {
// split 20/20/16
hash.resize(56);
memcpy(hash.data(), block1.data(), 20);
memcpy(hash.data() + 20, block2.data(), 20);
memcpy(hash.data() + 40, block3.data(), 16);
}
block3.fill(0);
} else {
// split 20/20
hash.resize(40);
memcpy(hash.data(), block1.data(), 20);
memcpy(hash.data() + 20, block2.data(), 20);
}
block2.fill(0);
} else {
// entirely block1
hash.resize(20);
memcpy(hash.data(), block1.data(), 20);
}
block1.fill(0);
//MCH: to store hash as a String...
QString output, tmp;
unsigned char *digest;
digest = (unsigned char*) hash.data();
for (int i = 0; i < 20; ++i)
output += tmp.sprintf("%02x", digest[i]);
output = output.toUpper();
qDebug()<<"HASH::Result == "<<output;
return output;
}
