source/union_domain.c

   1 #include <ctype.h>
   2 #include <stdio.h>
   3 #include <stdlib.h>
   4 #include "../include/cloog/cloog.h"
   5
   6 #define ALLOC(type) (type*)malloc(sizeof(type))
   7 #define ALLOCN(type,n) (type*)malloc((n)*sizeof(type))
   8
   9 void cloog_named_domain_list_free(CloogNamedDomainList *list)
  10 {
  11         while (list != NULL) {
  12                 CloogNamedDomainList *temp = list->next;
  13                 cloog_domain_free(list->domain);
  14                 cloog_scattering_free(list->scattering);
  15                 free(list->name);
  16                 free(list);
  17                 list = temp;
  18         }
  19 }
  20
  21 CloogUnionDomain *cloog_union_domain_alloc(int nb_par)
  22 {
  23         CloogUnionDomain *ud;
  24
  25         ud = ALLOC(CloogUnionDomain);
  26         if (!ud)
  27                 cloog_die("memory overflow.\n");
  28
  29         ud->domain = NULL;
  30         ud->next_domain = &ud->domain;
  31
  32         ud->n_name[CLOOG_PARAM] = nb_par;
  33         ud->n_name[CLOOG_ITER] = 0;
  34         ud->n_name[CLOOG_SCAT] = 0;
  35
  36         ud->name[CLOOG_PARAM] = NULL;
  37         ud->name[CLOOG_ITER] = NULL;
  38         ud->name[CLOOG_SCAT] = NULL;
  39
  40         return ud;
  41 }
  42
  43 void cloog_union_domain_free(CloogUnionDomain *ud)
  44 {
  45         int i;
  46         int j;
  47
  48         if (!ud)
  49                 return;
  50
  51         for (i = 0; i < 3; ++i) {
  52                 if (!ud->name[i])
  53                         continue;
  54                 for (j = 0; j < ud->n_name[i]; ++i)
  55                         free(ud->name[i][j]);
  56                 free(ud->name[i]);
  57         }
  58
  59         cloog_named_domain_list_free(ud->domain);
  60
  61         free(ud);
  62 }
  63
  64 /**
  65  * Add a domain with scattering function to the union of domains.
  66  * name may be NULL and is duplicated if it is not.
  67  * domain and scattering are taken over by the CloogUnionDomain.
  68  * scattering may be NULL.
  69  */
  70 CloogUnionDomain *cloog_union_domain_add_domain(CloogUnionDomain *ud,
  71         const char *name, CloogDomain *domain, CloogScattering *scattering,
  72         void *usr)
  73 {
  74         CloogNamedDomainList *named;
  75         int n;
  76
  77         if (!ud)
  78                 return NULL;
  79
  80         named = ALLOC(CloogNamedDomainList);
  81         if (!named)
  82                 cloog_die("memory overflow.\n");
  83
  84         if (ud->name[CLOOG_ITER])
  85                 cloog_die("iterator names must be set after adding domains.\n");
  86         if (ud->name[CLOOG_SCAT])
  87                 cloog_die("scattering names must be set after adding domains.\n");
  88
  89         n = cloog_domain_dimension(domain);
  90         if (n > ud->n_name[CLOOG_ITER])
  91                 ud->n_name[CLOOG_ITER] = n;
  92
  93         if (scattering) {
  94                 n = cloog_scattering_dimension(scattering, domain);
  95                 if (n > ud->n_name[CLOOG_SCAT])
  96                         ud->n_name[CLOOG_SCAT] = n;
  97         }
  98
  99         named->domain = domain;
 100         named->scattering = scattering;
 101         named->name = name ? strdup(name) : NULL;
 102         named->usr = usr;
 103         named->next = NULL;
 104
 105         *ud->next_domain = named;
 106         ud->next_domain = &named->next;
 107
 108         return ud;
 109 }
 110
 111 /**
 112  * Set the name of parameter, iterator or scattering dimension
 113  * at the specified position.  The name is duplicated.
 114  */
 115 CloogUnionDomain *cloog_union_domain_set_name(CloogUnionDomain *ud,
 116         enum cloog_dim_type type, int index, const char *name)
 117 {
 118         int i;
 119
 120         if (!ud)
 121                 return ud;
 122
 123         if (type != CLOOG_PARAM &&
 124             type != CLOOG_ITER &&
 125             type != CLOOG_SCAT)
 126                 cloog_die("invalid dim type\n");
 127
 128         if (index < 0 || index >= ud->n_name[type])
 129                 cloog_die("index out of range\n");
 130
 131         if (!ud->name[type]) {
 132                 ud->name[type] = ALLOCN(char *, ud->n_name[type]);
 133                 if (!ud->name[type])
 134                         cloog_die("memory overflow.\n");
 135                 for (i = 0; i < ud->n_name[type]; ++i)
 136                         ud->name[type][i] = NULL;
 137         }
 138
 139         free(ud->name[type][index]);
 140         ud->name[type][index] = strdup(name);
 141         if (!ud->name[type][index])
 142                 cloog_die("memory overflow.\n");
 143
 144         return ud;
 145 }
 146
 147 static char *next_line(FILE *input, char *line, unsigned len)
 148 {
 149         char *p;
 150
 151         do {
 152                 if (!(p = fgets(line, len, input)))
 153                         return NULL;
 154                 while (isspace(*p) && *p != '\n')
 155                         ++p;
 156         } while (*p == '#' || *p == '\n');
 157
 158         return p;
 159 }
 160
 161 /**
 162  * cloog_scattering_list_read
 163  * Read in a list of scattering functions for the nb_statements
 164  * domains in loop.
 165  */
 166 static CloogScatteringList *cloog_scattering_list_read(FILE * foo,
 167         CloogDomain **domain, int nb_statements, int nb_parameters)
 168 {
 169     int nb_scat = 0;
 170     char s[MAX_STRING];
 171     CloogScatteringList *list = NULL, **next = &list;
 172
 173     /* We read first the number of scattering functions in the list. */
 174     do {
 175         if (!fgets(s, MAX_STRING, foo))
 176             break;
 177     } while ((*s=='#' || *s=='\n') || (sscanf(s, " %d", &nb_scat) < 1));
 178
 179     if (nb_scat == 0)
 180         return NULL;
 181
 182     if (nb_scat != nb_statements)
 183         cloog_die("wrong number of scattering functions.\n");
 184
 185     while (nb_scat--) {
 186         *next = (CloogScatteringList *)malloc(sizeof(CloogScatteringList));
 187         (*next)->scatt = cloog_domain_read_scattering(*domain, foo);
 188         (*next)->next = NULL;
 189
 190         next = &(*next)->next;
 191         domain++;
 192     }
 193     return list;
 194 }
 195
 196 static CloogUnionDomain *set_names_from_list(CloogUnionDomain *ud,
 197         enum cloog_dim_type type, int n, char **names)
 198 {
 199         int i;
 200
 201         if (!names)
 202                 return ud;
 203
 204         for (i = 0; i < n; ++i) {
 205                 ud = cloog_union_domain_set_name(ud, type, i, names[i]);
 206                 free(names[i]);
 207         }
 208         free(names);
 209
 210         return ud;
 211 }
 212
 213 /**
 214  * Fill up a CloogUnionDomain from information in a CLooG input file.
 215  * The language and the context are assumed to have been read from
 216  * the input file already.
 217  */
 218 CloogUnionDomain *cloog_union_domain_read(FILE *file, int nb_par,
 219         CloogOptions *options)
 220 {
 221         int op1, op2, op3;
 222         char line[MAX_STRING];
 223         CloogDomain **domain;
 224         CloogUnionDomain *ud;
 225         CloogScatteringList *scatteringl;
 226         int i;
 227         int n_iter = -1;
 228         int n_dom;
 229         char **names;
 230
 231         ud = cloog_union_domain_alloc(nb_par);
 232
 233         names = cloog_names_read_strings(file, nb_par);
 234         ud = set_names_from_list(ud, CLOOG_PARAM, nb_par, names);
 235
 236         /* We read the number of statements. */
 237         if (!next_line(file, line, sizeof(line)))
 238                 cloog_die("Input error.\n");
 239         if (sscanf(line, "%d", &n_dom) != 1)
 240                 cloog_die("Input error.\n");
 241
 242         domain = ALLOCN(CloogDomain *, n_dom);
 243         if (!domain)
 244                 cloog_die("memory overflow.\n");
 245
 246         for (i = 0; i < n_dom; ++i) {
 247                 int dim;
 248
 249                 domain[i] = cloog_domain_union_read(options->state, file,
 250                                                     nb_par);
 251                 dim = cloog_domain_dimension(domain[i]);
 252                 if (dim > n_iter)
 253                         n_iter = dim;
 254
 255                 /* To read that stupid "0 0 0" line. */
 256                 if (!next_line(file, line, sizeof(line)))
 257                         cloog_die("Input error.\n");
 258                 if (sscanf(line, " %d %d %d", &op1, &op2, &op3) != 3)
 259                         cloog_die("Input error.\n");
 260         }
 261
 262         /* Reading of the iterator names. */
 263         names = cloog_names_read_strings(file, n_iter);
 264
 265         /* Reading and putting the scattering data in program structure. */
 266         scatteringl = cloog_scattering_list_read(file, domain, n_dom, nb_par);
 267
 268         if (scatteringl) {
 269                 CloogScatteringList *is, *next;
 270
 271                 if (cloog_scattering_list_lazy_same(scatteringl))
 272                         cloog_msg(options, CLOOG_WARNING,
 273                                   "some scattering functions are similar.\n");
 274
 275                 for (i = 0, is = scatteringl; i < n_dom; ++i, is = next) {
 276                         next = is->next;
 277                         ud = cloog_union_domain_add_domain(ud, NULL, domain[i],
 278                                                               is->scatt, NULL);
 279                         free(is);
 280                 }
 281         } else {
 282                 for (i = 0; i < n_dom; ++i)
 283                         ud = cloog_union_domain_add_domain(ud, NULL, domain[i],
 284                                                                 NULL, NULL);
 285         }
 286
 287         ud = set_names_from_list(ud, CLOOG_ITER, n_iter, names);
 288
 289         if (scatteringl) {
 290                 int n_scat = ud->n_name[CLOOG_SCAT];
 291                 names = cloog_names_read_strings(file, n_scat);
 292                 ud = set_names_from_list(ud, CLOOG_SCAT, n_scat, names);
 293         }
 294
 295         free(domain);
 296
 297         return ud;
 298 }