FilterSpec.c

Go to the documentation of this file.

#include <stdio.h>
#include <stdlib.h>
#include <dlfcn.h>
#include <pvm3.h>
#include "FilterSpec.h"
#include "Messages.h"

/*
 * Matheus 14,07/2004: changed all this stuff
 */

/* Constructor and destroyer **********************************************/
FilterSpec *createFilterSpec(char *filterName, char *libname) {
        int i;
        FilterSpec *fs = (FilterSpec *)malloc(sizeof(FilterSpec));
        for (i=0;i<MAXINSTANCES;i++){
                fs->filterPlacement.hosts[i] = (char*)malloc(sizeof(char)*MAX_HNAME_LENGTH);
                fs->filterPlacement.numInstances = 0;
        }
        strncpy(fs->name, filterName, MAX_FNAME_LENGTH);
        strncpy(fs->libname, libname, MAX_LNAME_LENGTH);
        return fs;
}

void destroyFilterSpec(FilterSpec *f){
        //we dont need to free stuff, everything is allocated statically
        free(f);
}
/**************************************************************************/

/* add hosts *************************************************************/
/// adds a host to the filter, return 1 on success 0 otherwise
int addHostToFilter(FilterSpec *fs, char *hostName){

        if (fs->filterPlacement.numInstances >= MAXINSTANCES){
                printf("FilterSpec.c: cant add host, maximum number of hosts reached for this filter");
                return -1;
        }
        else{
                strncpy(fs->filterPlacement.hosts[fs->filterPlacement.numInstances++], hostName, MAX_HNAME_LENGTH);
        }

        return (1);
}
/// adds a host qty times
int addHostsToFilter(FilterSpec *fs, char *hostName, int qty){
        int i;
        for (i=0; i<qty; i++){
                if (!addHostToFilter(fs, hostName)) return -1;
        }
        return (1);
}
/****************************************************************************/

/* add streams **************************************************************/
/// Adds a stream to the inputs of a filter
int addInputToFilter(FilterSpec *fs, StreamSpec *ss){
        if (fs->numInputs >= MAXINPSTREAMS)
                return 0;
        
        fs->inputs[fs->numInputs++] = ss;
        return 1;
}
/// Adds a stream to the outputs of a filter
int addOutputToFilter(FilterSpec *fs, StreamSpec *ss){
        if (fs->numInputs >= MAXOUTSTREAMS)
                return 0;
        
        fs->outputs[fs->numOutputs++] = ss;
        return 1;
}
/***************************************************************************/

/* Spawns the instances of a filter */
int fsSpawnInstances(FilterSpec *fs, char *command, char **argvSpawn){
        int j, spawnReturn;
        
        //for each instance of this filter...
        for(j = 0; j < fs->filterPlacement.numInstances; j++) { 
                // runs the instance
                char hname[MAX_HNAME_LENGTH+1];
                strcpy(hname, fs->filterPlacement.hosts[j]);
                spawnReturn = pvm_spawn(command, argvSpawn, PvmTaskHost,
                                hname, 1, 
                                &(fs->filterPlacement.tids[j]));

                //error handling
                if (spawnReturn < 0) {
                        printf("FilterSpec.c: Error creating filter %s, host %s\n", 
                                        fs->name, hname);
                        pvm_perror("");
                        exit(1);
                }
                else if (spawnReturn == 0){
                        printf("FilterSpec.c: Error creating filter %s, host %s\n", 
                                        fs->name, hname);
                        switch ((fs->filterPlacement.tids[j])){
                                case PvmBadParam:
                                        printf("FilterSpec.c: Invalid argument\n");
                                        break;
                                case PvmNoHost:
                                        printf("FilterSpec.c: Specified host not on virtual machine\n");
                                        break;
                                case PvmNoFile:
                                        printf("FilterSpec.c: Cant find executable on remote machine\n");
                                        break;
                                case PvmNoMem:
                                        printf("FilterSpec.c: out of memory\n");
                                        break;
                                case PvmSysErr:
                                        printf("FilterSpec.c: system error\n");
                                        break;
                                case PvmOutOfRes:
                                        printf("FilterSpec.c: out of resources\n");
                                        break;
                                default:
                                        pvm_perror("pvm_spawn()");
                                        break;
                        }
                        return -1;
                }

                pvm_notify(PvmTaskExit, MSGT_TEXIT, 1, &(fs->filterPlacement.tids[j]));
                pvm_notify(PvmHostDelete, MSGT_HDEL, 1, &(fs->filterPlacement.tids[j]));
        }

        return 0;

}

---