static
void removeEdgesToAccept(NGHolder &g, NFAVertex v) {
const auto &reports = g[v].reports;
assert(!reports.empty());
// We remove any accept edge with a non-empty subset of the reports of v.
set<NFAEdge> dead;
for (const auto &e : in_edges_range(g.accept, g)) {
NFAVertex u = source(e, g);
const auto &r = g[u].reports;
if (!r.empty() && is_subset_of(r, reports)) {
DEBUG_PRINTF("vertex %u\n", g[u].index);
dead.insert(e);
}
}
for (const auto &e : in_edges_range(g.acceptEod, g)) {
NFAVertex u = source(e, g);
const auto &r = g[u].reports;
if (!r.empty() && is_subset_of(r, reports)) {
DEBUG_PRINTF("vertex %u\n", g[u].index);
dead.insert(e);
}
}
assert(!dead.empty());
remove_edges(dead, g);
}
/**
* Test that for Jpeg files that use the JFIF colorspace, they are
* directly embedded into the PDF (without re-encoding) when that
* makes sense.
*/
DEF_TEST(PDFJpegEmbedTest, r) {
const char test[] = "PDFJpegEmbedTest";
SkAutoTUnref<SkData> mandrillData(
load_resource(r, test, "mandrill_512_q075.jpg"));
SkAutoTUnref<SkData> cmykData(load_resource(r, test, "CMYK.jpg"));
if (!mandrillData || !cmykData) {
return;
}
SkDynamicMemoryWStream pdf;
SkAutoTUnref<SkDocument> document(SkDocument::CreatePDF(&pdf));
SkCanvas* canvas = document->beginPage(642, 1028);
canvas->clear(SK_ColorLTGRAY);
SkBitmap bm1(bitmap_from_data(mandrillData));
canvas->drawBitmap(bm1, 65.0, 0.0, NULL);
SkBitmap bm2(bitmap_from_data(cmykData));
canvas->drawBitmap(bm2, 0.0, 512.0, NULL);
canvas->flush();
document->endPage();
document->close();
SkAutoTUnref<SkData> pdfData(pdf.copyToData());
SkASSERT(pdfData);
pdf.reset();
REPORTER_ASSERT(r, is_subset_of(mandrillData, pdfData));
// This JPEG uses a nonstandard colorspace - it can not be
// embedded into the PDF directly.
REPORTER_ASSERT(r, !is_subset_of(cmykData, pdfData));
}
int set_compare(word w1, word w2){
Map m1 = (Map) w1.v;
Map m2 = (Map) w2.v;
return get_size_Map(m1) == get_size_Map(m2) && is_subset_of(m1, m2);
}
/**
* Test that for Jpeg files that use the JFIF colorspace, they are
* directly embedded into the PDF (without re-encoding) when that
* makes sense.
*/
DEF_TEST(PDFJpegEmbedTest, r) {
const char test[] = "PDFJpegEmbedTest";
SkAutoTUnref<SkData> mandrillData(
load_resource(r, test, "mandrill_512_q075.jpg"));
SkAutoTUnref<SkData> cmykData(load_resource(r, test, "CMYK.jpg"));
if (!mandrillData || !cmykData) {
return;
}
SkDynamicMemoryWStream pdf;
SkAutoTUnref<SkDocument> document(SkDocument::CreatePDF(&pdf));
SkCanvas* canvas = document->beginPage(642, 1028);
canvas->clear(SK_ColorLTGRAY);
SkBitmap bm1(bitmap_from_data(mandrillData));
canvas->drawBitmap(bm1, 65.0, 0.0, NULL);
SkBitmap bm2(bitmap_from_data(cmykData));
canvas->drawBitmap(bm2, 0.0, 512.0, NULL);
canvas->flush();
document->endPage();
document->close();
SkAutoTUnref<SkData> pdfData(pdf.copyToData());
SkASSERT(pdfData);
pdf.reset();
// Test disabled, waiting on resolution to http://skbug.com/3180
// REPORTER_ASSERT(r, is_subset_of(mandrillData, pdfData));
// This JPEG uses a nonstandard colorspace - it can not be
// embedded into the PDF directly.
REPORTER_ASSERT(r, !is_subset_of(cmykData, pdfData));
// The following is for debugging purposes only.
const char* outputPath = getenv("SKIA_TESTS_PDF_JPEG_EMBED_OUTPUT_PATH");
if (outputPath) {
SkFILEWStream output(outputPath);
if (output.isValid()) {
output.write(pdfData->data(), pdfData->size());
}
}
}
int is_clique(int node, Map * adj_list, int size){
word w, w2;
Map map = create_Map(size, compare, hash_int, empty(), 1);
Iterator iter = get_Iterator(adj_list[node]);
while(!is_empty(iter)){
w = next_value(iter);
w2.i = ((Node) w.v)->index;
put(map, w2, w);
}
while(get_size_Map(map) > 0){
iter = get_Iterator(map);
w = next_key(iter);
rem(map, w);
if(!is_subset_of(map, adj_list[w.i])){
destroy_Map(map);
return 0;
}
}
destroy_Map(map);
return 1;
}
bool ast_gen::current_schedule_dimension_is_parallel(isl_ast_build * builder)
{
isl::union_map schedule = isl_ast_build_get_schedule(builder);
isl::space schedule_space = isl_ast_build_get_schedule_space(builder);
int dimension = schedule_space.dimension(isl::space::output) - 1;
isl::printer printer(m_model.context);
if (verbose<ast_gen>::enabled())
{
cout << " Schedule: " << endl;
printer.print_each_in(schedule);
cout << " Current dimension = " << dimension << endl;
}
auto dependencies = m_order;
dependencies.map_domain_through(schedule);
dependencies.map_range_through(schedule);
if (dependencies.is_empty())
{
return true;
}
auto schedule_deps = dependencies.single_map();
if (verbose<ast_gen>::enabled())
{
cout << " Schedule dependencies: " << endl;
printer.print_each_in(schedule_deps);
}
for (int i = 0; i < dimension; i++)
schedule_deps = isl_map_equate(schedule_deps.copy(),
isl_dim_out, i,
isl_dim_in, i);
if (verbose<ast_gen>::enabled())
{
cout << " Unsatisfied schedule dependencies: " << endl;
printer.print_each_in(schedule_deps);
}
auto all_zero_deps = isl::map::universe(schedule_deps.get_space());
all_zero_deps = isl_map_equate(all_zero_deps.copy(),
isl_dim_out, dimension,
isl_dim_in, dimension);
bool is_parallel = schedule_deps.is_subset_of(all_zero_deps);
if (!is_parallel && verbose<ast_gen>::enabled())
{
auto violating_deps = schedule_deps;
violating_deps.subtract(all_zero_deps);
cout << " Dependencies preventing parallelization: " << endl;
printer.print_each_in(violating_deps);
}
return is_parallel;
}
/*
if can find adj_list[i] that is a clique
remove i, all edges from i;
ordering[o++] = i;
cliques[c++] = adj_list[i];
else find adj_list[i] with smallest clique weight
remove i, all edges from i;
ordering[o++] = i;
make adj_list[i] a clique;
cliques[c++] = adj_list[i];
*/
Elimination elim(int size, Map * adj_list, Neighborhood * partial_order,
Map node_map){
Map ordering, cliques, max_cliques, trashcan;
int i, j, clique_exists, min_node, subset, index1, index2;
float min_weight, weight;
word w, w2, child, child2;
Iterator iter, iter2;
Map nodes = create_Map(size, compare, hash_int, empty(), 1);
Map roots = create_Map(size, compare, hash_int, empty(), 1);
int ** fill_ins;
fill_ins = (int **) malloc(sizeof(int *) * size);
fill_ins[0] = (int *) malloc(sizeof(int) * size * size);
for(i = 1; i < size; i++){
fill_ins[i] = fill_ins[i - 1] + size;
}
for(i = 0; i < size; i++){
for(j = 0; j < size; j++){
fill_ins[i][j] = 0;
}
}
for(i = 0; i < size; i++){
w.i = i;
put(nodes, w, w);
}
find_roots(partial_order, nodes, roots);
ordering = create_Map(size + 1, compare, hash_int, empty(), 1);
cliques = create_Map(size + 1, set_compare, hash_set, empty(), 1);
while(get_size_Map(nodes) > 0){
clique_exists = 0;
iter = get_Iterator(roots);
while(!is_empty(iter)){
w = next_key(iter);
if(is_clique_heuristic(w.i, adj_list) && is_clique(w.i, adj_list, size)){
clique_exists = 1;
break;
}
}
if(!clique_exists){
min_weight = LONG_MAX;
iter = get_Iterator(roots);
while(!is_empty(iter)){
w = next_value(iter);
weight = 0;
iter2 = get_Iterator(adj_list[w.i]);
while(!is_empty(iter2)){
weight += ((Node) next_value(iter2).v)->weight;
}
if(weight < min_weight){
min_weight = weight;
min_node = w.i;
}
}
w.i = min_node;
}
min_node = w.i;
rem(nodes, w);
remove_node(partial_order, w.i);
empty_Map(roots);
find_roots(partial_order, nodes, roots);
put(ordering, w, w);
child.v = adj_list[w.i];
if(!find((Map) child.v, w)){
child2.v = create_Node(w.i, 0);
put(node_map, child2, child2);
put((Map) child.v, w, child2);
}
child.v = copy_Map((Map) child.v);
put(cliques, child, child);
iter = get_Iterator(adj_list[min_node]);
i = 0;
while(!is_empty(iter)){
child = next_value(iter);
rem(adj_list[((Node) child.v)->index], w);
}
iter = create_Iterator(adj_list[min_node]);
while(!is_empty(iter)){
child = next_value(iter);
index1 = ((Node) child.v)->index;
w.i = index1;
iter2 = get_Iterator(adj_list[min_node]);
while(!is_empty(iter2)){
child2 = next_value(iter2);
index2 = ((Node) child2.v)->index;
if(index1 != index2){
w2.i = index2;
if(index1 < index2 && !find(adj_list[index1], w2)){
fill_ins[index1][index2] = 1;
}
put(adj_list[index1], w2, child2);
}
}
}
destroy_Iterator(iter);
}
destroy_Map(nodes);
destroy_Map(roots);
max_cliques = create_Map(size, set_compare, hash_set, empty(), 2);
trashcan = create_Map(size, set_compare, hash_set, empty(), 2);
while(get_size_Map(cliques) > 0){
iter = get_Iterator(cliques);
child = next_key(iter);
rem(cliques, child);
subset = 0;
while(!is_empty(iter)){
child2 = next_key(iter);
if(is_subset_of((Map) child2.v, (Map) child.v)){
rem(cliques, child2);
put(trashcan, child2, child2);
} else if(is_subset_of((Map) child.v, (Map) child2.v)){
subset = 1;
break;
}
}
if(!subset){
put(max_cliques, child, child);
} else {
put(trashcan, child, child);
}
}
destroy_Map(cliques);
iter = get_Iterator(trashcan);
while(!is_empty(iter)){
child = next_key(iter);
destroy_Map((Map) child.v);
}
destroy_Map(trashcan);
return create_Elimination(ordering, max_cliques, fill_ins, node_map);
}
bool FCA::BitSet::is_proper_subset_of(const FCA::BitSet &a) const
{
return is_subset_of(a) && m_bs != a.m_bs;
}