/**
- * collectd - src/sn_stage.c
+ * libsortnetwork - src/sn_stage.c
* Copyright (C) 2008-2010 Florian octo Forster
*
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation; only version 2 of the License is applicable.
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at
+ * your option) any later version.
*
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * General Public License for more details.
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
+ * for more details.
*
- * You should have received a copy of the GNU General Public License along
- * with this program; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
* Authors:
* Florian octo Forster <ff at octo.it>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
+#include <errno.h>
#include "sn_comparator.h"
#include "sn_stage.h"
sn_comparator_t *temp;
int i;
+ if ((s == NULL) || (c == NULL))
+ return (EINVAL);
+
+ i = sn_stage_comparator_check_conflict (s, c);
+ if (i != 0)
+ return (i);
+
temp = (sn_comparator_t *) realloc (s->comparators,
(s->comparators_num + 1) * sizeof (sn_comparator_t));
if (temp == NULL)
- return (-1);
+ return (ENOMEM);
s->comparators = temp;
temp = NULL;
int nmemb = s->comparators_num - (c_num + 1);
sn_comparator_t *temp;
+ if ((s == NULL) || (s->comparators_num <= c_num))
+ return (EINVAL);
+
assert (c_num < s->comparators_num);
assert (c_num >= 0);
sn_stage_t *sn_stage_clone (const sn_stage_t *s)
{
sn_stage_t *s_copy;
+ int i;
s_copy = sn_stage_create (s->depth);
if (s_copy == NULL)
return (NULL);
}
- memcpy (s_copy->comparators, s->comparators,
- s->comparators_num * sizeof (sn_comparator_t));
+ for (i = 0; i < s->comparators_num; i++)
+ {
+ SN_COMP_MIN (s_copy->comparators + i) = SN_COMP_MIN (s->comparators + i);
+ SN_COMP_MAX (s_copy->comparators + i) = SN_COMP_MAX (s->comparators + i);
+ SN_COMP_USER_DATA (s_copy->comparators + i) = NULL;
+ SN_COMP_FREE_FUNC (s_copy->comparators + i) = NULL;
+ }
s_copy->comparators_num = s->comparators_num;
return (s_copy);
{
int i;
+ if (s == NULL)
+ return (EINVAL);
+
for (i = 0; i < s->comparators_num; i++)
sn_comparator_invert (s->comparators + i);
{
int i;
+ if ((s == NULL) || (inputs_num < 2))
+ return (EINVAL);
+
+ sw %= inputs_num;
+ if (sw == 0)
+ return (0);
+
for (i = 0; i < s->comparators_num; i++)
sn_comparator_shift (s->comparators + i, sw, inputs_num);
return (0);
} /* int sn_stage_shift */
+static int sn_stage_unify__qsort_callback (const void *p0, const void *p1) /* {{{ */
+{
+ return (sn_comparator_compare (p0, p1));
+} /* }}} int sn_stage_unify__qsort_callback */
+
+int sn_stage_unify (sn_stage_t *s) /* {{{ */
+{
+ if (s == NULL)
+ return (EINVAL);
+
+ qsort (s->comparators,
+ (size_t) s->comparators_num,
+ sizeof (*s->comparators),
+ sn_stage_unify__qsort_callback);
+
+ return (0);
+} /* }}} int sn_stage_unify */
+
int sn_stage_swap (sn_stage_t *s, int con0, int con1)
{
int i;
+ if (s == NULL)
+ return (EINVAL);
+
for (i = 0; i < s->comparators_num; i++)
sn_comparator_swap (s->comparators + i, con0, con1);
int new_position = input;
int i;
+ if ((s == NULL) || (input < 0))
+ return (-EINVAL);
+
for (i = 0; i < s->comparators_num; i++)
{
sn_comparator_t *c = s->comparators + i;
return (new_position);
} /* int sn_stage_cut_at */
+int sn_stage_cut (sn_stage_t *s, int *mask, /* {{{ */
+ sn_stage_t **prev)
+{
+ int i;
+
+ if ((s == NULL) || (mask == NULL) || (prev == NULL))
+ return (EINVAL);
+
+ for (i = 0; i < s->comparators_num; i++)
+ {
+ sn_comparator_t *c = s->comparators + i;
+ int left = SN_COMP_LEFT (c);
+ int right = SN_COMP_RIGHT (c);
+
+ if ((mask[left] == 0)
+ && (mask[right] == 0))
+ continue;
+
+ /* Check if we need to update the cut position */
+ if ((mask[left] != mask[right])
+ && ((mask[left] > 0) || (mask[right] < 0)))
+ {
+ int tmp;
+ int j;
+
+ tmp = mask[right];
+ mask[right] = mask[left];
+ mask[left] = tmp;
+
+ for (j = s->depth - 1; j >= 0; j--)
+ sn_stage_swap (prev[j],
+ left, right);
+ }
+
+ sn_stage_comparator_remove (s, i);
+ i--;
+ } /* for (i = 0; i < s->comparators_num; i++) */
+
+ return (0);
+} /* }}} int sn_stage_cut */
+
int sn_stage_remove_input (sn_stage_t *s, int input)
{
int i;
#define SNPRINTF_OR_FAIL(...) \
status = snprintf (buffer, buffer_size, __VA_ARGS__); \
- if ((status < 1) || (status >= buffer_size)) \
+ if ((status < 1) || (((size_t) status) >= buffer_size)) \
return (-1); \
buffer += status; \
buffer_size -= status;
return (s);
} /* sn_stage_t *sn_stage_unserialize */
-/* vim: set shiftwidth=2 softtabstop=2 expandtab : */
+int sn_stage_compare (const sn_stage_t *s0, const sn_stage_t *s1) /* {{{ */
+{
+ int status;
+ int i;
+
+ if (s0 == s1)
+ return (0);
+ else if (s0 == NULL)
+ return (-1);
+ else if (s1 == NULL)
+ return (1);
+
+ if (s0->comparators_num < s1->comparators_num)
+ return (-1);
+ else if (s0->comparators_num > s1->comparators_num)
+ return (1);
+
+ for (i = 0; i < s0->comparators_num; i++)
+ {
+ status = sn_comparator_compare (s0->comparators + i, s1->comparators + i);
+ if (status != 0)
+ return (status);
+ }
+
+ return (0);
+} /* }}} int sn_stage_compare */
+
+uint64_t sn_stage_get_hashval (const sn_stage_t *s) /* {{{ */
+{
+ uint64_t hash;
+ int i;
+
+ if (s == NULL)
+ return (0);
+
+ hash = (uint64_t) s->depth;
+
+ for (i = 0; i < s->comparators_num; i++)
+ hash = (hash * 99991) + sn_comparator_get_hashval (s->comparators + i);
+
+ return (hash);
+} /* }}} uint64_t sn_stage_get_hashval */
+
+/* vim: set shiftwidth=2 softtabstop=2 expandtab fdm=marker : */
projects / sort-networks.git / blobdiff