mirror of https://github.com/KLayout/klayout.git
452 lines
16 KiB
C++
452 lines
16 KiB
C++
|
|
/*
|
|
|
|
KLayout Layout Viewer
|
|
Copyright (C) 2006-2018 Matthias Koefferlein
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
|
|
*/
|
|
|
|
|
|
#include "tlUnitTest.h"
|
|
|
|
#include "dbTilingProcessor.h"
|
|
#include "dbTextWriter.h"
|
|
#include "gsiExpression.h"
|
|
#include "gsiDecl.h"
|
|
#include "dbWriter.h"
|
|
#include "dbSaveLayoutOptions.h"
|
|
#include "dbShapeProcessor.h"
|
|
|
|
#include <cstdlib>
|
|
#include <QMutex>
|
|
#include <QMutexLocker>
|
|
|
|
unsigned int get_rand()
|
|
{
|
|
// provide a 32bit random number also for MSVC's 16bit rand():
|
|
return (((unsigned int) rand ()) << 16) ^ ((unsigned int) rand ());
|
|
}
|
|
|
|
TEST(1a)
|
|
{
|
|
db::Layout out;
|
|
unsigned int o1 = out.insert_layer ();
|
|
db::Cell *otop = &out.cell (out.add_cell ("TOP"));
|
|
|
|
db::TilingProcessor tp;
|
|
tp.output ("o", out, otop->cell_index (), o1);
|
|
tp.queue ("_output(o, Box.new(0, 0, 1000, 2000))");
|
|
tp.execute ("test");
|
|
|
|
tl::OutputStringStream sstream;
|
|
tl::OutputStream stream (sstream);
|
|
db::TextWriter writer (stream);
|
|
writer.write (out);
|
|
// tiles not specified, bbox is empty -> no execution
|
|
EXPECT_EQ (sstream.string (), "begin_lib 0.001\nbegin_cell {TOP}\nend_cell\nend_lib\n");
|
|
}
|
|
|
|
TEST(1b)
|
|
{
|
|
db::Layout out;
|
|
unsigned int o1 = out.insert_layer ();
|
|
db::Cell *otop = &out.cell (out.add_cell ("TOP"));
|
|
|
|
db::TilingProcessor tp;
|
|
tp.output ("o", out, otop->cell_index (), o1);
|
|
tp.queue ("_output(o, Box.new(0, 0, 1000, 2000))");
|
|
tp.execute ("test");
|
|
|
|
tp.tile_size (1.0, 1.0);
|
|
tp.tiles (1, 1);
|
|
tp.tile_origin (0.0, 0.0);
|
|
tp.execute ("test");
|
|
|
|
tl::OutputStringStream sstream;
|
|
tl::OutputStream stream (sstream);
|
|
db::TextWriter writer (stream);
|
|
writer.write (out);
|
|
EXPECT_EQ (sstream.string (), "begin_lib 0.001\nbegin_cell {TOP}\nbox -1 -1 {0 0} {1000 2000}\nend_cell\nend_lib\n");
|
|
}
|
|
|
|
TEST(1c)
|
|
{
|
|
db::Layout out;
|
|
unsigned int o1 = out.insert_layer ();
|
|
db::Cell *otop = &out.cell (out.add_cell ("TOP"));
|
|
|
|
db::TilingProcessor tp;
|
|
tp.output ("o", out, otop->cell_index (), o1);
|
|
tp.var ("bx", tl::Variant (db::Box (0, 0, 1000, 2000)));
|
|
tp.queue ("_output(o, bx)");
|
|
|
|
tp.tile_size (1.0, 1.0);
|
|
tp.tiles (1, 1);
|
|
tp.tile_origin (0.0, 0.0);
|
|
tp.execute ("test");
|
|
|
|
tl::OutputStringStream sstream;
|
|
tl::OutputStream stream (sstream);
|
|
db::TextWriter writer (stream);
|
|
writer.write (out);
|
|
EXPECT_EQ (sstream.string (), "begin_lib 0.001\nbegin_cell {TOP}\nbox -1 -1 {0 0} {1000 2000}\nend_cell\nend_lib\n");
|
|
}
|
|
|
|
static std::string to_s (const db::Layout &ly, db::cell_index_type top, unsigned int layer)
|
|
{
|
|
std::string r;
|
|
for (db::RecursiveShapeIterator i (ly, ly.cell (top), layer); ! i.at_end (); ++i) {
|
|
if (! r.empty ()) {
|
|
r += ";";
|
|
}
|
|
r += i.shape ().to_string ();
|
|
}
|
|
return r;
|
|
}
|
|
|
|
TEST(2)
|
|
{
|
|
db::Layout ly;
|
|
unsigned int l1 = ly.insert_layer (db::LayerProperties (1, 0));
|
|
unsigned int l2 = ly.insert_layer (db::LayerProperties (2, 0));
|
|
unsigned int o1 = ly.insert_layer (db::LayerProperties (10, 0));
|
|
unsigned int o2 = ly.insert_layer (db::LayerProperties (11, 0));
|
|
unsigned int o3 = ly.insert_layer (db::LayerProperties (12, 0));
|
|
db::cell_index_type top = ly.add_cell ("TOP");
|
|
db::cell_index_type c1 = ly.add_cell ("C1");
|
|
db::cell_index_type c2 = ly.add_cell ("C2");
|
|
ly.cell (c1).shapes (l1).insert (db::Box (0, 0, 30, 30));
|
|
ly.cell (c2).shapes (l2).insert (db::Box (0, 0, 30, 30));
|
|
ly.cell (top).insert (db::CellInstArray (c1, db::Trans (db::Vector (0, 0))));
|
|
ly.cell (top).insert (db::CellInstArray (c1, db::Trans (db::Vector (50, 0))));
|
|
ly.cell (top).insert (db::CellInstArray (c1, db::Trans (db::Vector (50, 40))));
|
|
ly.cell (top).insert (db::CellInstArray (c2, db::Trans (db::Vector (10, 10))));
|
|
ly.cell (top).insert (db::CellInstArray (c2, db::Trans (db::Vector (80, 40))));
|
|
ly.cell (top).insert (db::CellInstArray (c2, db::Trans (db::Vector (110, 40))));
|
|
ly.cell (top).shapes (l2).insert (db::Box (60, 10, 70, 20));
|
|
|
|
{
|
|
db::TilingProcessor tp;
|
|
tp.input ("i1", db::RecursiveShapeIterator (ly, ly.cell (top), l1));
|
|
tp.input ("i2", db::RecursiveShapeIterator (ly, ly.cell (top), l2));
|
|
tp.output ("o1", ly, top, o1);
|
|
tp.output ("o2", ly, top, o2);
|
|
tp.output ("o3", ly, top, o3);
|
|
tp.queue ("_output(o1, _tile ? (i1 & i2 & _tile) : (i1 & i2), false)");
|
|
tp.queue ("!_tile && _output(o2, i1.outside(i2), false)");
|
|
tp.queue ("_tile && _output(o3, _tile, false)");
|
|
tp.execute ("test");
|
|
|
|
EXPECT_EQ (to_s (ly, top, o1), "polygon (60,10;60,20;70,20;70,10);polygon (10,10;10,30;30,30;30,10)");
|
|
EXPECT_EQ (to_s (ly, top, o2), "polygon (50,40;50,70;80,70;80,40)");
|
|
EXPECT_EQ (to_s (ly, top, o3), "");
|
|
|
|
ly.clear_layer (o1);
|
|
ly.clear_layer (o2);
|
|
|
|
EXPECT_EQ (to_s (ly, top, o1), "");
|
|
EXPECT_EQ (to_s (ly, top, o2), "");
|
|
|
|
tp.tile_size (0.025, 0.025);
|
|
|
|
tp.execute ("test");
|
|
|
|
EXPECT_EQ (to_s (ly, top, o1), "polygon (10,10;10,23;20,23;20,10);polygon (10,23;10,30;20,30;20,23);polygon (20,10;20,23;30,23;30,10);polygon (20,23;20,30;30,30;30,23);polygon (60,10;60,20;70,20;70,10)");
|
|
EXPECT_EQ (to_s (ly, top, o2), "");
|
|
EXPECT_EQ (to_s (ly, top, o3), "polygon (-5,-2;-5,23;20,23;20,-2);polygon (-5,23;-5,48;20,48;20,23);polygon (-5,48;-5,73;20,73;20,48);polygon (20,-2;20,23;45,23;45,-2);polygon (20,23;20,48;45,48;45,23);polygon (20,48;20,73;45,73;45,48);polygon (45,-2;45,23;70,23;70,-2);polygon (45,23;45,48;70,48;70,23);polygon (45,48;45,73;70,73;70,48);polygon (70,-2;70,23;95,23;95,-2);polygon (70,23;70,48;95,48;95,23);polygon (70,48;70,73;95,73;95,48);polygon (95,-2;95,23;120,23;120,-2);polygon (95,23;95,48;120,48;120,23);polygon (95,48;95,73;120,73;120,48);polygon (120,-2;120,23;145,23;145,-2);polygon (120,23;120,48;145,48;145,23);polygon (120,48;120,73;145,73;145,48)");
|
|
}
|
|
|
|
{
|
|
ly.clear_layer (o1);
|
|
ly.clear_layer (o2);
|
|
ly.clear_layer (o3);
|
|
|
|
db::TilingProcessor tp;
|
|
tp.input ("i1", db::RecursiveShapeIterator (ly, ly.cell (top), l1));
|
|
tp.input ("i2", db::RecursiveShapeIterator (ly, ly.cell (top), l2));
|
|
tp.output ("o1", ly, top, o1);
|
|
tp.output ("o2", ly, top, o2);
|
|
tp.output ("o3", ly, top, o3);
|
|
tp.queue ("_output(o1, i1 & i2)");
|
|
tp.queue ("!_tile && _output(o2, i1.outside(i2))");
|
|
tp.queue ("_output(o3, _tile)");
|
|
tp.execute ("test");
|
|
|
|
EXPECT_EQ (to_s (ly, top, o1), "polygon (60,10;60,20;70,20;70,10);polygon (10,10;10,30;30,30;30,10)");
|
|
EXPECT_EQ (to_s (ly, top, o2), "polygon (50,40;50,70;80,70;80,40)");
|
|
EXPECT_EQ (to_s (ly, top, o3), "");
|
|
|
|
ly.clear_layer (o1);
|
|
ly.clear_layer (o2);
|
|
|
|
EXPECT_EQ (to_s (ly, top, o1), "");
|
|
EXPECT_EQ (to_s (ly, top, o2), "");
|
|
|
|
tp.tile_size (0.025, 0.025);
|
|
|
|
tp.execute ("test");
|
|
|
|
EXPECT_EQ (to_s (ly, top, o1), "polygon (10,10;10,23;20,23;20,10);polygon (10,23;10,30;20,30;20,23);polygon (20,10;20,23;30,23;30,10);polygon (20,23;20,30;30,30;30,23);polygon (60,10;60,20;70,20;70,10)");
|
|
EXPECT_EQ (to_s (ly, top, o2), "");
|
|
EXPECT_EQ (to_s (ly, top, o3), "polygon (-5,-2;-5,23;20,23;20,-2);polygon (-5,23;-5,48;20,48;20,23);polygon (-5,48;-5,73;20,73;20,48);polygon (20,-2;20,23;45,23;45,-2);polygon (20,23;20,48;45,48;45,23);polygon (20,48;20,73;45,73;45,48);polygon (45,-2;45,23;70,23;70,-2);polygon (45,23;45,48;70,48;70,23);polygon (45,48;45,73;70,73;70,48);polygon (70,-2;70,23;95,23;95,-2);polygon (70,23;70,48;95,48;95,23);polygon (70,48;70,73;95,73;95,48);polygon (95,-2;95,23;120,23;120,-2);polygon (95,23;95,48;120,48;120,23);polygon (95,48;95,73;120,73;120,48);polygon (120,-2;120,23;145,23;145,-2);polygon (120,23;120,48;145,48;145,23);polygon (120,48;120,73;145,73;145,48)");
|
|
}
|
|
}
|
|
|
|
TEST(3)
|
|
{
|
|
db::Layout ly;
|
|
unsigned int l1 = ly.insert_layer (db::LayerProperties (1, 0));
|
|
unsigned int l2 = ly.insert_layer (db::LayerProperties (2, 0));
|
|
unsigned int l3 = ly.insert_layer (db::LayerProperties (3, 0));
|
|
unsigned int o1 = ly.insert_layer (db::LayerProperties (10, 0));
|
|
unsigned int o2 = ly.insert_layer (db::LayerProperties (11, 0));
|
|
unsigned int o3 = ly.insert_layer (db::LayerProperties (12, 0));
|
|
unsigned int q1 = ly.insert_layer (db::LayerProperties (20, 0));
|
|
unsigned int q2 = ly.insert_layer (db::LayerProperties (21, 0));
|
|
unsigned int q3 = ly.insert_layer (db::LayerProperties (22, 0));
|
|
db::cell_index_type top = ly.add_cell ("TOP");
|
|
|
|
for (size_t i = 0; i < 50000; ++i) {
|
|
db::Coord x = get_rand () % 10000000;
|
|
db::Coord y = get_rand () % 10000000;
|
|
ly.cell (top).shapes (l1).insert (db::Box (x, y, x + 10000, y + 10000));
|
|
x = get_rand () % 10000000;
|
|
y = get_rand () % 10000000;
|
|
ly.cell (top).shapes (l2).insert (db::Box (x, y, x + 10000, y + 10000));
|
|
x = get_rand () % 10000000;
|
|
y = get_rand () % 10000000;
|
|
ly.cell (top).shapes (l3).insert (db::Box (x, y, x + 10000, y + 10000));
|
|
}
|
|
|
|
db::TilingProcessor tp;
|
|
tp.input ("i1", db::RecursiveShapeIterator (ly, ly.cell (top), l1));
|
|
db::Region ir2 (db::RecursiveShapeIterator (ly, ly.cell (top), l2));
|
|
tp.input ("i2", ir2.begin_iter ().first, ir2.begin_iter ().second);
|
|
EXPECT_EQ (ir2.has_valid_polygons (), false);
|
|
db::Region ir3 (db::RecursiveShapeIterator (ly, ly.cell (top), l3));
|
|
ir3.flatten ();
|
|
tp.input ("i3", ir3.begin_iter ().first, ir3.begin_iter ().second);
|
|
EXPECT_EQ (ir3.has_valid_polygons (), true);
|
|
tp.output ("o1", ly, top, o1);
|
|
db::Region or2;
|
|
tp.output ("o2", or2);
|
|
tp.output ("o3", ly, top, o3);
|
|
tp.queue ("_output(o1, i1 ^ i2)");
|
|
tp.queue ("_output(o2, i1 ^ i3)");
|
|
tp.queue ("_output(o3, i2 ^ i3)");
|
|
|
|
int v = tl::verbosity ();
|
|
tl::verbosity (21);
|
|
tp.execute ("test");
|
|
tl::verbosity (v);
|
|
|
|
for (db::Region::const_iterator o = or2.begin (); ! o.at_end (); ++o) {
|
|
ly.cell (top).shapes (o2).insert (*o);
|
|
}
|
|
|
|
ly.swap_layers (o1, q1);
|
|
ly.swap_layers (o2, q2);
|
|
ly.swap_layers (o3, q3);
|
|
|
|
tp.tile_size (100, 100);
|
|
tp.set_threads (2);
|
|
|
|
db::Region or2_copy;
|
|
or2.swap (or2_copy);
|
|
|
|
v = tl::verbosity ();
|
|
tl::verbosity (11);
|
|
tp.execute ("test");
|
|
tl::verbosity (v);
|
|
|
|
for (db::Region::const_iterator o = or2.begin (); ! o.at_end (); ++o) {
|
|
ly.cell (top).shapes (o2).insert (*o);
|
|
}
|
|
|
|
EXPECT_EQ (or2.has_valid_polygons (), true);
|
|
EXPECT_EQ (or2.size () / 2000, size_t (50)); // because we use rand () the value may vary - it's only accurate to 2%
|
|
EXPECT_EQ (or2_copy.has_valid_polygons (), true);
|
|
EXPECT_EQ (or2_copy.size () / 2000, size_t (40)); // because we use rand () the value may vary - it's only accurate to 2%
|
|
EXPECT_EQ ((or2 ^ or2_copy).empty (), true);
|
|
|
|
#if 0
|
|
{
|
|
db::SaveLayoutOptions options;
|
|
db::Writer writer (options);
|
|
tl::OutputFile file ("x.gds");
|
|
writer.write (ly, file);
|
|
}
|
|
#endif
|
|
|
|
db::ShapeProcessor sp;
|
|
|
|
EXPECT_EQ (ly.cell (top).shapes (o1).empty (), false);
|
|
EXPECT_EQ (ly.cell (top).shapes (q1).empty (), false);
|
|
db::Shapes x1;
|
|
sp.boolean (ly, ly.cell (top), o1, ly, ly.cell (top), q1, x1, db::BooleanOp::Xor, true);
|
|
EXPECT_EQ (x1.empty (), true);
|
|
|
|
EXPECT_EQ (ly.cell (top).shapes (o2).empty (), false);
|
|
EXPECT_EQ (ly.cell (top).shapes (q2).empty (), false);
|
|
db::Shapes x2;
|
|
sp.boolean (ly, ly.cell (top), o2, ly, ly.cell (top), q2, x2, db::BooleanOp::Xor, true);
|
|
EXPECT_EQ (x2.empty (), true);
|
|
|
|
EXPECT_EQ (ly.cell (top).shapes (o3).empty (), false);
|
|
EXPECT_EQ (ly.cell (top).shapes (q3).empty (), false);
|
|
db::Shapes x3;
|
|
sp.boolean (ly, ly.cell (top), o3, ly, ly.cell (top), q3, x3, db::BooleanOp::Xor, true);
|
|
EXPECT_EQ (x3.empty (), true);
|
|
}
|
|
|
|
TEST(4)
|
|
{
|
|
// different DBU's
|
|
|
|
db::Layout ly1;
|
|
ly1.dbu (0.01);
|
|
unsigned int l11 = ly1.insert_layer (db::LayerProperties (1, 0));
|
|
db::cell_index_type top1 = ly1.add_cell ("TOP");
|
|
ly1.cell (top1).shapes (l11).insert (db::Box (10, 20, 30, 40));
|
|
|
|
db::Layout ly2;
|
|
ly2.dbu (0.001);
|
|
unsigned int l12 = ly2.insert_layer (db::LayerProperties (1, 0));
|
|
db::cell_index_type top2 = ly2.add_cell ("TOP");
|
|
ly2.cell (top2).shapes (l12).insert (db::Box (100, 200, 301, 401));
|
|
|
|
db::Layout o;
|
|
o.dbu (0.0001);
|
|
unsigned int l1o = o.insert_layer (db::LayerProperties (1, 0));
|
|
unsigned int l2o = o.insert_layer (db::LayerProperties (2, 0));
|
|
unsigned int l3o = o.insert_layer (db::LayerProperties (3, 0));
|
|
db::cell_index_type topo = o.add_cell ("TOP");
|
|
|
|
{
|
|
db::TilingProcessor tp;
|
|
tp.input ("i1", db::RecursiveShapeIterator (ly1, ly1.cell (top1), l11));
|
|
tp.input ("i2", db::RecursiveShapeIterator (ly2, ly2.cell (top2), l12));
|
|
tp.output ("o1", o, topo, l1o);
|
|
tp.output ("o2", o, topo, l2o);
|
|
tp.output ("o3", o, topo, l3o);
|
|
tp.queue ("_output(o1, _tile ? ((i1 ^ i2) & _tile) : (i1 ^ i2), false)");
|
|
tp.queue ("_output(o2, i1, true)");
|
|
tp.queue ("_output(o3, i2, true)");
|
|
tp.execute ("test");
|
|
|
|
EXPECT_EQ (to_s (o, topo, l1o), "");
|
|
EXPECT_EQ (to_s (o, topo, l2o), "polygon (1000,2000;1000,4000;3000,4000;3000,2000)");
|
|
EXPECT_EQ (to_s (o, topo, l3o), "polygon (1000,2000;1000,4000;3000,4000;3000,2000)");
|
|
|
|
o.clear_layer (l1o);
|
|
o.clear_layer (l2o);
|
|
o.clear_layer (l3o);
|
|
|
|
tp.set_dbu (0.001);
|
|
tp.execute ("test");
|
|
|
|
EXPECT_EQ (to_s (o, topo, l1o), "polygon (3000,2000;3000,4000;1000,4000;1000,4010;3010,4010;3010,2000)");
|
|
EXPECT_EQ (to_s (o, topo, l2o), "polygon (1000,2000;1000,4000;3000,4000;3000,2000)");
|
|
EXPECT_EQ (to_s (o, topo, l3o), "polygon (1000,2000;1000,4010;3010,4010;3010,2000)");
|
|
|
|
o.clear_layer (l1o);
|
|
o.clear_layer (l2o);
|
|
o.clear_layer (l3o);
|
|
|
|
tp.tile_size (0.1, 0.1);
|
|
|
|
tp.execute ("test");
|
|
|
|
EXPECT_EQ (to_s (o, topo, l1o), "polygon (1000,4000;1000,4010;1510,4010;1510,4000);polygon (1510,4000;1510,4010;2510,4010;2510,4000);polygon (3000,2000;3000,2510;3010,2510;3010,2000);polygon (3000,2510;3000,3510;3010,3510;3010,2510);polygon (3000,3510;3000,4000;2510,4000;2510,4010;3010,4010;3010,3510)");
|
|
|
|
o.clear_layer (l1o);
|
|
o.clear_layer (l2o);
|
|
o.clear_layer (l3o);
|
|
|
|
tp.tile_size (1000, 1000);
|
|
tp.set_scale_to_dbu (false);
|
|
tp.execute ("test");
|
|
|
|
EXPECT_EQ (to_s (o, topo, l1o), "polygon (100,200;100,400;300,400;300,200);polygon (1000,2000;1000,4010;3010,4010;3010,2000)");
|
|
EXPECT_EQ (to_s (o, topo, l2o), "polygon (100,200;100,400;300,400;300,200)");
|
|
EXPECT_EQ (to_s (o, topo, l3o), "polygon (1000,2000;1000,4010;3010,4010;3010,2000)");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
class MyTilingOutputReceiver
|
|
: public db::TileOutputReceiver
|
|
{
|
|
public:
|
|
MyTilingOutputReceiver (double *sum, int *n)
|
|
: mp_sum (sum), mp_n (n)
|
|
{ }
|
|
|
|
MyTilingOutputReceiver ()
|
|
: mp_sum (0), mp_n (0)
|
|
{ }
|
|
|
|
void add (double x) const
|
|
{
|
|
static QMutex lock;
|
|
QMutexLocker locker (&lock);
|
|
*mp_sum += x;
|
|
*mp_n += 1;
|
|
}
|
|
|
|
private:
|
|
double *mp_sum;
|
|
int *mp_n;
|
|
};
|
|
|
|
namespace gsi
|
|
{
|
|
DB_PUBLIC gsi::Class<db::TileOutputReceiver> &dbdecl_TileOutputReceiverBase ();
|
|
}
|
|
|
|
gsi::Class<MyTilingOutputReceiver> decl_MyTilingOutputReceiver (gsi::dbdecl_TileOutputReceiverBase (), "db", "MyTileOutputReceiver",
|
|
gsi::method ("add", &MyTilingOutputReceiver::add)
|
|
);
|
|
|
|
// Multithreaded, access to _rec()
|
|
// This will mainly test the ability of gsi::Proxy to manage references
|
|
// in a multithreaded case.
|
|
TEST(5)
|
|
{
|
|
db::Layout ly1;
|
|
ly1.dbu (0.001);
|
|
unsigned int l11 = ly1.insert_layer (db::LayerProperties (1, 0));
|
|
db::cell_index_type top1 = ly1.add_cell ("TOP");
|
|
ly1.cell (top1).shapes (l11).insert (db::Box (0, 0, 50000, 50000));
|
|
|
|
double sum = 0.0;
|
|
int num = 0;
|
|
MyTilingOutputReceiver *rec = new MyTilingOutputReceiver (&sum, &num);
|
|
|
|
db::TilingProcessor tp;
|
|
tp.set_threads (4);
|
|
tp.tile_size (0.11, 0.17);
|
|
tp.input ("i1", db::RecursiveShapeIterator (ly1, ly1.cell (top1), l11));
|
|
tp.output ("o1", 0, rec, db::ICplxTrans ());
|
|
tp.queue ("_rec(o1).add((i1 & _tile).area)");
|
|
tp.execute ("test");
|
|
|
|
EXPECT_EQ (sum, 2500000000);
|
|
EXPECT_EQ (num, 134225);
|
|
}
|