isl_dim.h File Reference

#include <isl_ctx.h>

Go to the source code of this file.

Data Structures
struct	isl_dim
Enumerations
enum	isl_dim_type {   isl_dim_param, isl_dim_in, isl_dim_out, isl_dim_set = isl_dim_out,   isl_dim_div, isl_dim_all }
Functions
struct isl_dim *	isl_dim_alloc (struct isl_ctx *ctx, unsigned nparam, unsigned n_in, unsigned n_out)
struct isl_dim *	isl_dim_set_alloc (struct isl_ctx *ctx, unsigned nparam, unsigned dim)
struct isl_dim *	isl_dim_copy (struct isl_dim *dim)
struct isl_dim *	isl_dim_cow (struct isl_dim *dim)
void	isl_dim_free (struct isl_dim *dim)
struct isl_dim *	isl_dim_set_name (struct isl_dim *dim, enum isl_dim_type type, unsigned pos, const char *name)
const char *	isl_dim_get_name (struct isl_dim *dim, enum isl_dim_type type, unsigned pos)
struct isl_dim *	isl_dim_extend (struct isl_dim *dim, unsigned nparam, unsigned n_in, unsigned n_out)
struct isl_dim *	isl_dim_add (struct isl_dim *dim, enum isl_dim_type type, unsigned n)
struct isl_dim *	isl_dim_join (struct isl_dim *left, struct isl_dim *right)
struct isl_dim *	isl_dim_product (struct isl_dim *left, struct isl_dim *right)
struct isl_dim *	isl_dim_map (struct isl_dim *dim)
struct isl_dim *	isl_dim_reverse (struct isl_dim *dim)
struct isl_dim *	isl_dim_drop (struct isl_dim *dim, enum isl_dim_type type, unsigned first, unsigned num)
struct isl_dim *	isl_dim_drop_inputs (struct isl_dim *dim, unsigned first, unsigned n)
struct isl_dim *	isl_dim_drop_outputs (struct isl_dim *dim, unsigned first, unsigned n)
struct isl_dim *	isl_dim_domain (struct isl_dim *dim)
struct isl_dim *	isl_dim_range (struct isl_dim *dim)
struct isl_dim *	isl_dim_underlying (struct isl_dim *dim, unsigned n_div)
int	isl_dim_equal (struct isl_dim *dim1, struct isl_dim *dim2)
int	isl_dim_match (struct isl_dim *dim1, enum isl_dim_type dim1_type, struct isl_dim *dim2, enum isl_dim_type dim2_type)
int	isl_dim_compatible (struct isl_dim *dim1, struct isl_dim *dim2)
unsigned	isl_dim_size (struct isl_dim *dim, enum isl_dim_type type)
unsigned	isl_dim_total (struct isl_dim *dim)

---

Enumeration Type Documentation

enum isl_dim_type

Enumerator:

isl_dim_param
isl_dim_in
isl_dim_out
isl_dim_set
isl_dim_div
isl_dim_all

Definition at line 24 of file isl_dim.h.

                  {
        isl_dim_param,
        isl_dim_in,
        isl_dim_out,
        isl_dim_set = isl_dim_out,
        isl_dim_div,
        isl_dim_all,
};

---

Function Documentation

struct isl_dim* isl_dim_alloc	(	struct isl_ctx *	ctx,
		unsigned	nparam,
		unsigned	n_in,
		unsigned	n_out
	)			[read]

Definition at line 4 of file isl_dim.c.

{
        struct isl_dim *dim;

        dim = isl_alloc_type(ctx, struct isl_dim);
        if (!dim)
                return NULL;

        dim->ctx = ctx;
        isl_ctx_ref(ctx);
        dim->ref = 1;
        dim->nparam = nparam;
        dim->n_in = n_in;
        dim->n_out = n_out;

        dim->n_name = 0;
        dim->names = NULL;

        return dim;
}

struct isl_dim* isl_dim_set_alloc	(	struct isl_ctx *	ctx,
		unsigned	nparam,
		unsigned	dim
	)			[read]

Definition at line 26 of file isl_dim.c.

{
        return isl_dim_alloc(ctx, nparam, 0, dim);
}

struct isl_dim* isl_dim_copy

(

struct isl_dim *

dim

)

[read]

Definition at line 174 of file isl_dim.c.

{
        if (!dim)
                return NULL;

        dim->ref++;
        return dim;
}

struct isl_dim* isl_dim_cow

(

struct isl_dim *

dim

)

[read]

Definition at line 163 of file isl_dim.c.

{
        if (!dim)
                return NULL;

        if (dim->ref == 1)
                return dim;
        dim->ref--;
        return isl_dim_dup(dim);
}

void isl_dim_free

(

struct isl_dim *

dim

)

Definition at line 183 of file isl_dim.c.

{
        int i;

        if (!dim)
                return;

        if (--dim->ref > 0)
                return;

        for (i = 0; i < dim->n_name; ++i)
                isl_name_free(dim->ctx, dim->names[i]);
        free(dim->names);
        isl_ctx_deref(dim->ctx);
        
        free(dim);
}

struct isl_dim* isl_dim_set_name	(	struct isl_dim *	dim,
		enum isl_dim_type	type,
		unsigned	pos,
		const char *	name
	)			[read]

Definition at line 201 of file isl_dim.c.

{
        struct isl_name *name;
        if (!dim)
                return NULL;
        name = isl_name_get(dim->ctx, s);
        if (!name)
                goto error;
        return set_name(dim, type, pos, name);
error:
        isl_dim_free(dim);
        return NULL;
}

const char* isl_dim_get_name	(	struct isl_dim *	dim,
		enum isl_dim_type	type,
		unsigned	pos
	)

Definition at line 217 of file isl_dim.c.

{
        struct isl_name *name = get_name(dim, type, pos);
        return name ? name->name : NULL;
}

struct isl_dim* isl_dim_extend	(	struct isl_dim *	dim,
		unsigned	nparam,
		unsigned	n_in,
		unsigned	n_out
	)			[read]

Definition at line 258 of file isl_dim.c.

{
        struct isl_name **names = NULL;

        if (!dim)
                return NULL;
        if (dim->nparam == nparam && dim->n_in == n_in && dim->n_out == n_out)
                return dim;

        isl_assert(dim->ctx, dim->nparam <= nparam, goto error);
        isl_assert(dim->ctx, dim->n_in <= n_in, goto error);
        isl_assert(dim->ctx, dim->n_out <= n_out, goto error);

        dim = isl_dim_cow(dim);

        if (dim->names) {
                names = isl_calloc_array(dim->ctx, struct isl_name *,
                                         nparam + n_in + n_out);
                if (!names)
                        goto error;
                get_names(dim, isl_dim_param, 0, dim->nparam, names);
                get_names(dim, isl_dim_in, 0, dim->n_in, names + nparam);
                get_names(dim, isl_dim_out, 0, dim->n_out,
                                names + nparam + n_in);
                free(dim->names);
                dim->names = names;
                dim->n_name = nparam + n_in + n_out;
        }
        dim->nparam = nparam;
        dim->n_in = n_in;
        dim->n_out = n_out;

        return dim;
error:
        free(names);
        isl_dim_free(dim);
        return NULL;
}

struct isl_dim* isl_dim_add	(	struct isl_dim *	dim,
		enum isl_dim_type	type,
		unsigned	n
	)			[read]

Definition at line 298 of file isl_dim.c.

{
        switch (type) {
        case isl_dim_param:
                return isl_dim_extend(dim,
                                        dim->nparam + n, dim->n_in, dim->n_out);
        case isl_dim_in:
                return isl_dim_extend(dim,
                                        dim->nparam, dim->n_in + n, dim->n_out);
        case isl_dim_out:
                return isl_dim_extend(dim,
                                        dim->nparam, dim->n_in, dim->n_out + n);
        }
        return dim;
}

struct isl_dim* isl_dim_join	(	struct isl_dim *	left,
		struct isl_dim *	right
	)			[read]

Definition at line 315 of file isl_dim.c.

{
        struct isl_dim *dim;

        if (!left || !right)
                goto error;

        isl_assert(left->ctx, match(left, isl_dim_param, right, isl_dim_param),
                        goto error);
        isl_assert(left->ctx, match(left, isl_dim_out, right, isl_dim_in),
                        goto error);

        dim = isl_dim_alloc(left->ctx, left->nparam, left->n_in, right->n_out);
        if (!dim)
                goto error;

        dim = copy_names(dim, isl_dim_param, 0, left, isl_dim_param);
        dim = copy_names(dim, isl_dim_in, 0, left, isl_dim_in);
        dim = copy_names(dim, isl_dim_out, 0, right, isl_dim_out);

        isl_dim_free(left);
        isl_dim_free(right);

        return dim;
error:
        isl_dim_free(left);
        isl_dim_free(right);
        return NULL;
}

struct isl_dim* isl_dim_product	(	struct isl_dim *	left,
		struct isl_dim *	right
	)			[read]

Definition at line 345 of file isl_dim.c.

{
        struct isl_dim *dim;

        if (!left || !right)
                goto error;

        isl_assert(left->ctx, match(left, isl_dim_param, right, isl_dim_param),
                        goto error);

        dim = isl_dim_alloc(left->ctx, left->nparam,
                        left->n_in + right->n_in, left->n_out + right->n_out);
        if (!dim)
                goto error;

        dim = copy_names(dim, isl_dim_param, 0, left, isl_dim_param);
        dim = copy_names(dim, isl_dim_in, 0, left, isl_dim_in);
        dim = copy_names(dim, isl_dim_in, left->n_in, right, isl_dim_in);
        dim = copy_names(dim, isl_dim_out, 0, left, isl_dim_out);
        dim = copy_names(dim, isl_dim_out, left->n_out, right, isl_dim_out);

        isl_dim_free(left);
        isl_dim_free(right);

        return dim;
error:
        isl_dim_free(left);
        isl_dim_free(right);
        return NULL;
}

struct isl_dim* isl_dim_map

(

struct isl_dim *

dim

)

[read]

Definition at line 376 of file isl_dim.c.

{
        struct isl_name **names = NULL;

        if (!dim)
                return NULL;
        isl_assert(dim->ctx, dim->n_in == 0, goto error);
        if (dim->n_out == 0)
                return dim;
        dim = isl_dim_cow(dim);
        if (!dim)
                return NULL;
        if (dim->names) {
                names = isl_calloc_array(dim->ctx, struct isl_name *,
                                        dim->nparam + dim->n_out + dim->n_out);
                if (!names)
                        goto error;
                get_names(dim, isl_dim_param, 0, dim->nparam, names);
                get_names(dim, isl_dim_out, 0, dim->n_out, names + dim->nparam);
        }
        dim->n_in = dim->n_out;
        if (names) {
                copy_names(dim, isl_dim_out, 0, dim, isl_dim_in);
                free(dim->names);
                dim->names = names;
                dim->n_name = dim->nparam + dim->n_out + dim->n_out;
        }
        return dim;
error:
        isl_dim_free(dim);
        return NULL;
}

struct isl_dim* isl_dim_reverse

(

struct isl_dim *

dim

)

[read]

Definition at line 420 of file isl_dim.c.

{
        unsigned t;
        struct isl_name **names = NULL;

        if (!dim)
                return NULL;
        if (match(dim, isl_dim_in, dim, isl_dim_out))
                return dim;

        dim = isl_dim_cow(dim);
        if (!dim)
                return NULL;

        if (dim->names) {
                names = isl_alloc_array(dim->ctx, struct isl_name *,
                                        dim->n_in + dim->n_out);
                if (!names)
                        goto error;
                get_names(dim, isl_dim_in, 0, dim->n_in, names);
                get_names(dim, isl_dim_out, 0, dim->n_out, names + dim->n_in);
        }

        t = dim->n_in;
        dim->n_in = dim->n_out;
        dim->n_out = t;

        if (dim->names) {
                dim = set_names(dim, isl_dim_out, 0, dim->n_out, names);
                dim = set_names(dim, isl_dim_in, 0, dim->n_in, names + dim->n_out);
                free(names);
        }

        return dim;
error:
        free(names);
        isl_dim_free(dim);
        return NULL;
}

struct isl_dim* isl_dim_drop	(	struct isl_dim *	dim,
		enum isl_dim_type	type,
		unsigned	first,
		unsigned	num
	)			[read]

Definition at line 460 of file isl_dim.c.

{
        int i;

        if (!dim)
                return NULL;

        if (n == 0)
                return dim;

        isl_assert(dim->ctx, first + num <= n(dim, type), goto error);
        dim = isl_dim_cow(dim);
        if (!dim)
                goto error;
        if (dim->names) {
                for (i = 0; i < num; ++i)
                        isl_name_free(dim->ctx, get_name(dim, type, first+i));
                for (i = first+num; i < n(dim, type); ++i)
                        set_name(dim, type, i - num, get_name(dim, type, i));
                switch (type) {
                case isl_dim_param:
                        get_names(dim, isl_dim_in, 0, dim->n_in,
                                dim->names + offset(dim, isl_dim_in) - num);
                case isl_dim_in:
                        get_names(dim, isl_dim_out, 0, dim->n_out,
                                dim->names + offset(dim, isl_dim_out) - num);
                case isl_dim_out:
                        ;
                }
        }
        switch (type) {
        case isl_dim_param:     dim->nparam -= num; break;
        case isl_dim_in:        dim->n_in -= num; break;
        case isl_dim_out:       dim->n_out -= num; break;
        }
        return dim;
error:
        isl_dim_free(dim);
        return NULL;
}

struct isl_dim* isl_dim_drop_inputs	(	struct isl_dim *	dim,
		unsigned	first,
		unsigned	n
	)			[read]

Definition at line 502 of file isl_dim.c.

{
        return isl_dim_drop(dim, isl_dim_in, first, n);
}

struct isl_dim* isl_dim_drop_outputs	(	struct isl_dim *	dim,
		unsigned	first,
		unsigned	n
	)			[read]

Definition at line 508 of file isl_dim.c.

{
        return isl_dim_drop(dim, isl_dim_out, first, n);
}

struct isl_dim* isl_dim_domain

(

struct isl_dim *

dim

)

[read]

Definition at line 514 of file isl_dim.c.

{
        if (!dim)
                return NULL;
        dim = isl_dim_drop_outputs(dim, 0, dim->n_out);
        return isl_dim_reverse(dim);
}

struct isl_dim* isl_dim_range

(

struct isl_dim *

dim

)

[read]

Definition at line 522 of file isl_dim.c.

{
        if (!dim)
                return NULL;
        return isl_dim_drop_inputs(dim, 0, dim->n_in);
}

struct isl_dim* isl_dim_underlying	(	struct isl_dim *	dim,
		unsigned	n_div
	)			[read]

Definition at line 529 of file isl_dim.c.

{
        int i;

        if (!dim)
                return NULL;
        if (n_div == 0 &&
            dim->nparam == 0 && dim->n_in == 0 && dim->n_name == 0)
                return dim;
        dim = isl_dim_cow(dim);
        if (!dim)
                return NULL;
        dim->n_out += dim->nparam + dim->n_in + n_div;
        dim->nparam = 0;
        dim->n_in = 0;

        for (i = 0; i < dim->n_name; ++i)
                isl_name_free(dim->ctx, get_name(dim, isl_dim_out, i));
        dim->n_name = 0;

        return dim;
}

int isl_dim_equal	(	struct isl_dim *	dim1,
		struct isl_dim *	dim2
	)

Definition at line 557 of file isl_dim.c.

{
        return match(dim1, isl_dim_param, dim2, isl_dim_param) &&
               match(dim1, isl_dim_in, dim2, isl_dim_in) &&
               match(dim1, isl_dim_out, dim2, isl_dim_out);
}

int isl_dim_match	(	struct isl_dim *	dim1,
		enum isl_dim_type	dim1_type,
		struct isl_dim *	dim2,
		enum isl_dim_type	dim2_type
	)

Definition at line 243 of file isl_dim.c.

{
        return match(dim1, dim1_type, dim2, dim2_type);
}

int isl_dim_compatible	(	struct isl_dim *	dim1,
		struct isl_dim *	dim2
	)

Definition at line 564 of file isl_dim.c.

{
        return dim1->nparam == dim2->nparam &&
               dim1->n_in + dim1->n_out == dim2->n_in + dim2->n_out;
}

unsigned isl_dim_size	(	struct isl_dim *	dim,
		enum isl_dim_type	type
	)

Definition at line 127 of file isl_dim.c.

{
        return n(dim, type);
}

unsigned isl_dim_total

(

struct isl_dim *

dim

)

Definition at line 552 of file isl_dim.c.

{
        return dim->nparam + dim->n_in + dim->n_out;
}