Exemplo n.º 1
0
void create_pattern(gchar* name, PatternType type, gint iter, gint elem, gint level, GroupBlock* group)
{
	Verbose("Creating pattern%d \"%s\" elem %d level %d\n", type, name, elem, level);
	Pattern* pattern = pattern_new(type, iter, elem, level);

	gint groupSize = (group? group->groupsize : size);
	gint groupRank;
	if (group)
		MPI_Comm_rank(group->mpicomm, &groupRank);
	else
		groupRank = rank;

	Verbose("GroupSize = %d, GroupRank = %d\n", groupSize, groupRank);

	MPI_Type_contiguous(elem, MPI_BYTE, &pattern->eType);
	MPI_Type_commit(&pattern->eType);
	pattern->type_size = 1;

	switch (type) {
		/* contiguous data */
		case PATTERN1: {
			int array_sizes[] = { groupSize };
			int array_subsizes[] = { 1 };
			int array_starts[] = { groupRank };

			MPI_Type_create_subarray(
				1,				/* number of array dimensions*/
				array_sizes,	/* number of eTypes in each dimension of the full array*/
				array_subsizes,	/* number of eTypes in each dimension of the subarray */
				array_starts,	/* starting coordinates of the subarray in each dimension*/
				MPI_ORDER_C,	/* array storage order flag (state) */
				pattern->eType,	/* eType (old datatype) */
				&pattern->datatype);
			MPI_Type_commit(&pattern->datatype);
			break;
		}

		/* non-contiguous data */
		case PATTERN2: {
			int array_sizes[] = { iter, groupSize };
			int array_subsizes[] = { iter, 1 };
			int array_starts[] = { 0, groupRank };

			MPI_Type_create_subarray(
				2,				/* number of array dimensions*/
				array_sizes,	/* number of eTypes in each dimension of the full array*/
				array_subsizes,	/* number of eTypes in each dimension of the subarray */
				array_starts,	/* starting coordinates of the subarray in each dimension*/
				MPI_ORDER_C,	/* array storage order flag (state) */
				pattern->eType,	/* eType (old datatype) */
				&pattern->datatype);
			MPI_Type_commit(&pattern->datatype);
			break;
		}

		default: Error("Pattern%d not yet supported!\n", type);
	}

	g_hash_table_insert(patternMap, name, pattern);
}
Exemplo n.º 2
0
pattern* pattern_dup(const pattern* pat)
{
    static int dup_id = 0;
    pattern* dest = pattern_new(--dup_id);

    if (!dest)
        goto fail0;

    dest->events = evlist_dup(pat->events);

    if (!dest->events)
        goto fail1;

    dest->rt = rtdata_new(pat,  pattern_rtdata_get_cb,
                                pattern_rtdata_free_cb );
    if (!pat->rt)
        goto fail2;

    dest->loop_length =     pat->loop_length;

    dest->width_min =       pat->width_min;
    dest->width_max =       pat->width_max;

    dest->height_min =      pat->height_min;
    dest->height_max =      pat->height_max;

    dest->beats_per_bar =   pat->beats_per_bar;
    dest->beat_type =       pat->beat_type;
    dest->beat_ratio =      pat->beat_ratio;

/*    dest->seedtype =        pat->seedtype;
    dest->seed =            pat->seed;*/

    dest->evout =           pat->evout;

    return dest;

fail2:  evlist_free(pat->events);
fail1:  free(dest);
fail0:
    return 0;
}