read_xml_arch_file.h File Reference

#include "util.h"
#include "arch_types.h"

Include dependency graph for read_xml_arch_file.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	NUM_MODELS_IN_LIBRARY   4
#define	EMPTY_TYPE_INDEX   0
#define	IO_TYPE_INDEX   1

Functions
void	XmlReadArch (INP const char *ArchFile, INP boolean timing_enabled, OUTP struct s_arch *arch, OUTP t_type_descriptor **Types, OUTP int *NumTypes)
void	EchoArch (INP const char *EchoFile, INP const t_type_descriptor *Types, INP int NumTypes, struct s_arch *arch)

Macro Definition Documentation

#define EMPTY_TYPE_INDEX   0

Definition at line 15 of file read_xml_arch_file.h.

#define IO_TYPE_INDEX   1

Definition at line 16 of file read_xml_arch_file.h.

#define NUM_MODELS_IN_LIBRARY   4

Definition at line 14 of file read_xml_arch_file.h.

Function Documentation

void EchoArch	(	INP const char *	EchoFile,
		INP const t_type_descriptor *	Types,
		INP int	NumTypes,
		struct s_arch *	arch
	)

Definition at line 3294 of file read_xml_arch_file.c.

                                               {
    int i, j;
    FILE * Echo;
    t_model * cur_model;
    t_model_ports * model_port;
    struct s_linked_vptr *cur_vptr;

    Echo = my_fopen(EchoFile, "w", 0);
    cur_model = NULL;

    for (j = 0; j < 2; j++) {
        if (j == 0) {
            fprintf(Echo, "Printing user models \n");
            cur_model = arch->models;
        } else if (j == 1) {
            fprintf(Echo, "Printing library models \n");
            cur_model = arch->model_library;
        }
        while (cur_model) {
            fprintf(Echo, "Model: \"%s\"\n", cur_model->name);
            model_port = cur_model->inputs;
            while (model_port) {
                fprintf(Echo, "\tInput Ports: \"%s\" \"%d\" min_size=\"%d\"\n",
                        model_port->name, model_port->size,
                        model_port->min_size);
                model_port = model_port->next;
            }
            model_port = cur_model->outputs;
            while (model_port) {
                fprintf(Echo, "\tOutput Ports: \"%s\" \"%d\" min_size=\"%d\"\n",
                        model_port->name, model_port->size,
                        model_port->min_size);
                model_port = model_port->next;
            }
            cur_vptr = cur_model->pb_types;
            i = 0;
            while (cur_vptr != NULL) {
                fprintf(Echo, "\tpb_type %d: \"%s\"\n", i,
                        ((t_pb_type*) cur_vptr->data_vptr)->name);
                cur_vptr = cur_vptr->next;
                i++;
            }

            cur_model = cur_model->next;
        }
    }

    for (i = 0; i < NumTypes; ++i) {
        fprintf(Echo, "Type: \"%s\"\n", Types[i].name);
        fprintf(Echo, "\tcapacity: %d\n", Types[i].capacity);
        fprintf(Echo, "\theight: %d\n", Types[i].height);

        for (j = 0; j < Types[i].num_pins; j++) {
            fprintf(Echo, "\tis_Fc_frac: \n");
            fprintf(Echo, "\t\tPin number %d: %s\n", j,
                    (Types[i].is_Fc_frac[j] ? "TRUE" : "FALSE"));
            fprintf(Echo, "\tis_Fc_full_flex: \n");
            fprintf(Echo, "\t\tPin number %d: %s\n", j,
                    (Types[i].is_Fc_full_flex[j] ? "TRUE" : "FALSE"));
            fprintf(Echo, "\tFc_val: \n");
            fprintf(Echo, "\tPin number %d: %f\n", j, Types[i].Fc[j]);
        }
        fprintf(Echo, "\tnum_drivers: %d\n", Types[i].num_drivers);
        fprintf(Echo, "\tnum_receivers: %d\n", Types[i].num_receivers);
        fprintf(Echo, "\tindex: %d\n", Types[i].index);
        if (Types[i].pb_type) {
            PrintPb_types_rec(Echo, Types[i].pb_type, 2);
        }
        fprintf(Echo, "\n");
    }
    fclose(Echo);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void XmlReadArch	(	INP const char *	ArchFile,
		INP boolean	timing_enabled,
		OUTP struct s_arch *	arch,
		OUTP t_type_descriptor **	Types,
		OUTP int *	NumTypes
	)

Definition at line 2519 of file read_xml_arch_file.c.

                            {
    ezxml_t Cur, Next;
    const char *Prop;
    boolean power_reqd;

    /* Parse the file */
    Cur = ezxml_parse_file(ArchFile);
    if (NULL == Cur) {
        vpr_printf(TIO_MESSAGE_ERROR,
                "Unable to load architecture file '%s'.\n", ArchFile);
        exit(1);
    }

    /* Root node should be architecture */
    CheckElement(Cur, "architecture");
    /* TODO: do version processing properly with string delimiting on the . */
    Prop = FindProperty(Cur, "version", FALSE);
    if (Prop != NULL) {
        if (atof(Prop) > atof(VPR_VERSION)) {
            vpr_printf(TIO_MESSAGE_WARNING,
                    "This architecture version is for VPR %f while your current VPR version is " VPR_VERSION ", compatability issues may arise\n",
                    atof(Prop));
        }
        ezxml_set_attr(Cur, "version", NULL);
    }

    /* Process models */
    Next = FindElement(Cur, "models", TRUE);
    ProcessModels(Next, arch);
    FreeNode(Next);
    CreateModelLibrary(arch);

    /* Process layout */
    Next = FindElement(Cur, "layout", TRUE);
    ProcessLayout(Next, arch);
    FreeNode(Next);

    /* Process device */
    Next = FindElement(Cur, "device", TRUE);
    ProcessDevice(Next, arch, timing_enabled);
    FreeNode(Next);

    /* Process types */
    Next = FindElement(Cur, "complexblocklist", TRUE);
    ProcessComplexBlocks(Next, Types, NumTypes, timing_enabled);
    FreeNode(Next);

    /* Process switches */
    Next = FindElement(Cur, "switchlist", TRUE);
    ProcessSwitches(Next, &(arch->Switches), &(arch->num_switches),
            timing_enabled);
    FreeNode(Next);

    /* Process segments. This depends on switches */
    Next = FindElement(Cur, "segmentlist", TRUE);
    ProcessSegments(Next, &(arch->Segments), &(arch->num_segments),
            arch->Switches, arch->num_switches, timing_enabled);
    FreeNode(Next);

    /* Process directs */
    Next = FindElement(Cur, "directlist", FALSE);
    if (Next) {
        ProcessDirects(Next, &(arch->Directs), &(arch->num_directs),
                timing_enabled);
        FreeNode(Next);
    }

    /* Process architecture power information */

    /* If arch->power has been initialized, meaning the user has requested power estimation,
     * then the power architecture information is required.
     */
    if (arch->power) {
        power_reqd = TRUE;
    } else {
        power_reqd = FALSE;
    }

    Next = FindElement(Cur, "power", power_reqd);
    if (Next) {
        if (arch->power) {
            ProcessPower(Next, arch->power, *Types, *NumTypes);
        } else {
            /* This information still needs to be read, even if it is just
             * thrown away.
             */
            t_power_arch * power_arch_fake = (t_power_arch*) my_calloc(1,
                    sizeof(t_power_arch));
            ProcessPower(Next, power_arch_fake, *Types, *NumTypes);
            free(power_arch_fake);
        }
        FreeNode(Next);
    }

// Process Clocks
    Next = FindElement(Cur, "clocks", power_reqd);
    if (Next) {
        if (arch->clocks) {
            ProcessClocks(Next, arch->clocks);
        } else {
            /* This information still needs to be read, even if it is just
             * thrown away.
             */
            t_clock_arch * clocks_fake = (t_clock_arch*) my_calloc(1,
                    sizeof(t_clock_arch));
            ProcessClocks(Next, clocks_fake);
            free(clocks_fake->clock_inf);
            free(clocks_fake);
        }
        FreeNode(Next);
    }
    SyncModelsPbTypes(arch, *Types, *NumTypes);
    UpdateAndCheckModels(arch);

    /* Release the full XML tree */
    FreeNode(Cur);
}

Here is the call graph for this function:

Here is the caller graph for this function: