2 * collectd - src/sn_network.c
3 * Copyright (C) 2008,2009 Florian octo Forster
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License as published by the
7 * Free Software Foundation; only version 2 of the License is applicable.
9 * This program is distributed in the hope that it will be useful, but
10 * WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * General Public License for more details.
14 * You should have received a copy of the GNU General Public License along
15 * with this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
19 * Florian octo Forster <octo at verplant.org>
22 #ifndef _ISOC99_SOURCE
23 # define _ISOC99_SOURCE
25 #ifndef _POSIX_C_SOURCE
26 # define _POSIX_C_SOURCE 200112L
30 # define DPRINTF(...) fprintf (stderr, "sn_network: " __VA_ARGS__)
32 # define DPRINTF(...) /**/
42 #include "sn_network.h"
43 #include "sn_random.h"
45 sn_network_t *sn_network_create (int inputs_num) /* {{{ */
49 n = (sn_network_t *) malloc (sizeof (sn_network_t));
52 memset (n, '\0', sizeof (sn_network_t));
54 n->inputs_num = inputs_num;
57 } /* }}} sn_network_t *sn_network_create */
59 void sn_network_destroy (sn_network_t *n) /* {{{ */
64 if (n->stages != NULL)
67 for (i = 0; i < n->stages_num; i++)
69 sn_stage_destroy (n->stages[i]);
77 } /* }}} void sn_network_destroy */
79 sn_network_t *sn_network_create_odd_even_mergesort (int inputs_num) /* {{{ */
83 n = sn_network_create (inputs_num);
85 assert (inputs_num > 0);
98 s = sn_stage_create (/* depth = */ 0);
99 sn_stage_comparator_add (s, &c);
100 sn_network_stage_add (n, s);
106 sn_network_t *n_left;
107 sn_network_t *n_right;
111 inputs_left = inputs_num / 2;
112 inputs_right = inputs_num - inputs_left;
114 n_left = sn_network_create_odd_even_mergesort (inputs_left);
118 n_right = sn_network_create_odd_even_mergesort (inputs_right);
121 sn_network_destroy (n_left);
125 n = sn_network_combine_odd_even_merge (n_left, n_right);
127 sn_network_destroy (n_left);
128 sn_network_destroy (n_right);
131 sn_network_compress (n);
135 } /* }}} sn_network_t *sn_network_create_odd_even_mergesort */
137 int sn_network_stage_add (sn_network_t *n, sn_stage_t *s) /* {{{ */
141 temp = (sn_stage_t **) realloc (n->stages, (n->stages_num + 1)
142 * sizeof (sn_stage_t *));
147 SN_STAGE_DEPTH (s) = n->stages_num;
148 n->stages[n->stages_num] = s;
152 } /* }}} int sn_network_stage_add */
154 int sn_network_stage_remove (sn_network_t *n, int s_num) /* {{{ */
156 int nmemb = n->stages_num - (s_num + 1);
159 assert (s_num < n->stages_num);
161 sn_stage_destroy (n->stages[s_num]);
162 n->stages[s_num] = NULL;
166 memmove (n->stages + s_num, n->stages + (s_num + 1),
167 nmemb * sizeof (sn_stage_t *));
168 n->stages[n->stages_num - 1] = NULL;
172 /* Free the unused memory */
173 if (n->stages_num == 0)
180 temp = (sn_stage_t **) realloc (n->stages,
181 n->stages_num * sizeof (sn_stage_t *));
188 } /* }}} int sn_network_stage_remove */
190 sn_network_t *sn_network_clone (const sn_network_t *n) /* {{{ */
192 sn_network_t *n_copy;
195 n_copy = sn_network_create (n->inputs_num);
199 for (i = 0; i < n->stages_num; i++)
204 s = sn_stage_clone (n->stages[i]);
208 status = sn_network_stage_add (n_copy, s);
213 if (i < n->stages_num)
215 sn_network_destroy (n_copy);
220 } /* }}} sn_network_t *sn_network_clone */
222 int sn_network_show (sn_network_t *n) /* {{{ */
226 for (i = 0; i < n->stages_num; i++)
227 sn_stage_show (n->stages[i]);
230 } /* }}} int sn_network_show */
232 int sn_network_invert (sn_network_t *n) /* {{{ */
236 for (i = 0; i < n->stages_num; i++)
237 sn_stage_invert (n->stages[i]);
240 } /* }}} int sn_network_invert */
242 int sn_network_shift (sn_network_t *n, int sw) /* {{{ */
246 for (i = 0; i < n->stages_num; i++)
247 sn_stage_shift (n->stages[i], sw, SN_NETWORK_INPUT_NUM (n));
250 } /* }}} int sn_network_shift */
252 int sn_network_compress (sn_network_t *n) /* {{{ */
258 for (i = 1; i < n->stages_num; i++)
264 for (j = 0; j < SN_STAGE_COMP_NUM (s); j++)
266 sn_comparator_t *c = SN_STAGE_COMP_GET (s, j);
269 for (k = i - 1; k >= 0; k--)
273 conflict = sn_stage_comparator_check_conflict (n->stages[k], c);
288 sn_stage_comparator_add (n->stages[move_to], c);
289 sn_stage_comparator_remove (s, j);
295 while ((n->stages_num > 0)
296 && (SN_STAGE_COMP_NUM (n->stages[n->stages_num - 1]) == 0))
297 sn_network_stage_remove (n, n->stages_num - 1);
300 } /* }}} int sn_network_compress */
302 int sn_network_normalize (sn_network_t *n) /* {{{ */
306 for (i = 0; i < n->stages_num; i++)
313 for (j = 0; j < SN_STAGE_COMP_NUM (s); j++)
319 c = SN_STAGE_COMP_GET (s, j);
328 for (k = i; k < n->stages_num; k++)
329 sn_stage_swap (n->stages[k], min, max);
334 } /* for (j = 0 .. #comparators) */
335 } /* for (i = n->stages_num - 1 .. 0) */
338 } /* }}} int sn_network_normalize */
340 int sn_network_cut_at (sn_network_t *n, int input, /* {{{ */
341 enum sn_network_cut_dir_e dir)
344 int position = input;
346 for (i = 0; i < n->stages_num; i++)
352 new_position = sn_stage_cut_at (s, position, dir);
354 if (position != new_position)
358 for (j = 0; j < i; j++)
359 sn_stage_swap (n->stages[j], position, new_position);
362 position = new_position;
365 assert (((dir == DIR_MIN) && (position == 0))
366 || ((dir == DIR_MAX) && (position == (n->inputs_num - 1))));
368 for (i = 0; i < n->stages_num; i++)
369 sn_stage_remove_input (n->stages[i], position);
374 } /* }}} int sn_network_cut_at */
376 /* sn_network_concatenate
378 * `Glues' two networks together, resulting in a comparator network with twice
379 * as many inputs but one that doesn't really sort anymore. It produces a
380 * bitonic sequence, though, that can be used by the mergers below. */
381 static sn_network_t *sn_network_concatenate (sn_network_t *n0, /* {{{ */
389 stages_num = (n0->stages_num > n1->stages_num)
393 n = sn_network_create (n0->inputs_num + n1->inputs_num);
397 for (i = 0; i < stages_num; i++)
399 sn_stage_t *s = sn_stage_create (i);
401 if (i < n0->stages_num)
402 for (j = 0; j < SN_STAGE_COMP_NUM (n0->stages[i]); j++)
404 sn_comparator_t *c = SN_STAGE_COMP_GET (n0->stages[i], j);
405 sn_stage_comparator_add (s, c);
408 if (i < n1->stages_num)
409 for (j = 0; j < SN_STAGE_COMP_NUM (n1->stages[i]); j++)
411 sn_comparator_t *c_orig = SN_STAGE_COMP_GET (n1->stages[i], j);
412 sn_comparator_t c_copy;
414 SN_COMP_MIN(&c_copy) = SN_COMP_MIN(c_orig) + n0->inputs_num;
415 SN_COMP_MAX(&c_copy) = SN_COMP_MAX(c_orig) + n0->inputs_num;
417 sn_stage_comparator_add (s, &c_copy);
420 sn_network_stage_add (n, s);
424 } /* }}} sn_network_t *sn_network_concatenate */
426 static int sn_network_add_bitonic_merger_recursive (sn_network_t *n, /* {{{ */
436 s = sn_stage_create (n->stages_num);
442 for (i = low; i < (low + m); i++)
449 sn_stage_comparator_add (s, &c);
452 sn_network_stage_add (n, s);
454 sn_network_add_bitonic_merger_recursive (n, low, m);
455 sn_network_add_bitonic_merger_recursive (n, low + m, m);
458 } /* }}} int sn_network_add_bitonic_merger_recursive */
460 static int sn_network_add_bitonic_merger (sn_network_t *n) /* {{{ */
467 s = sn_stage_create (n->stages_num);
471 m = n->inputs_num / 2;
473 for (i = 0; i < m; i++)
478 c.max = n->inputs_num - (i + 1);
480 sn_stage_comparator_add (s, &c);
483 sn_network_stage_add (n, s);
485 sn_network_add_bitonic_merger_recursive (n, 0, m);
486 sn_network_add_bitonic_merger_recursive (n, m, m);
488 sn_network_add_bitonic_merger_recursive (n, 0, SN_NETWORK_INPUT_NUM (n));
492 } /* }}} int sn_network_add_bitonic_merger */
494 static int sn_network_add_odd_even_merger (sn_network_t *n, /* {{{ */
495 int *indizes_left, int indizes_left_num,
496 int *indizes_right, int indizes_right_num)
498 int tmp_left[indizes_left_num];
500 int tmp_right[indizes_left_num];
506 if ((indizes_left_num == 0) || (indizes_right_num == 0))
510 else if ((indizes_left_num == 1) && (indizes_right_num == 1))
515 c.min = *indizes_left;
516 c.max = *indizes_right;
518 s = sn_stage_create (n->stages_num);
522 sn_stage_comparator_add (s, &c);
523 sn_network_stage_add (n, s);
528 /* Merge odd sequences */
529 tmp_left_num = (indizes_left_num + 1) / 2;
530 for (i = 0; i < tmp_left_num; i++)
531 tmp_left[i] = indizes_left[2 * i];
533 tmp_right_num = (indizes_right_num + 1) / 2;
534 for (i = 0; i < tmp_right_num; i++)
535 tmp_right[i] = indizes_right[2 * i];
537 sn_network_add_odd_even_merger (n,
538 tmp_left, tmp_left_num,
539 tmp_right, tmp_right_num);
541 /* Merge even sequences */
542 tmp_left_num = indizes_left_num / 2;
543 for (i = 0; i < tmp_left_num; i++)
544 tmp_left[i] = indizes_left[(2 * i) + 1];
546 tmp_right_num = indizes_right_num / 2;
547 for (i = 0; i < tmp_right_num; i++)
548 tmp_right[i] = indizes_right[(2 * i) + 1];
550 sn_network_add_odd_even_merger (n,
551 tmp_left, tmp_left_num,
552 tmp_right, tmp_right_num);
554 /* Apply ``comparison-interchange'' operations. */
555 s = sn_stage_create (n->stages_num);
557 max_index = indizes_left_num + indizes_right_num;
558 if ((max_index % 2) == 0)
563 for (i = 1; i <= max_index; i += 2)
567 if (i < indizes_left_num)
568 c.min = indizes_left[i];
570 c.min = indizes_right[i - indizes_left_num];
572 if ((i + 1) < indizes_left_num)
573 c.max = indizes_left[i + 1];
575 c.max = indizes_right[i + 1 - indizes_left_num];
577 sn_stage_comparator_add (s, &c);
580 sn_network_stage_add (n, s);
583 } /* }}} int sn_network_add_odd_even_merger */
585 static sn_network_t *sn_network_combine_bitonic_shift (sn_network_t *n0, /* {{{ */
586 sn_network_t *n1, int do_shift)
589 sn_network_t *n1_clone;
592 n1_clone = sn_network_clone (n1);
593 if (n1_clone == NULL)
596 sn_network_invert (n1_clone);
598 n = sn_network_concatenate (n0, n1_clone);
602 sn_network_destroy (n1_clone);
605 shift = sn_bounded_random (0, SN_NETWORK_INPUT_NUM (n) - 1);
611 DPRINTF ("sn_network_combine_bitonic_shift: Shifting by %i.\n", shift);
612 sn_network_shift (n, shift);
615 sn_network_add_bitonic_merger (n);
618 } /* }}} sn_network_t *sn_network_combine_bitonic_shift */
620 sn_network_t *sn_network_combine_bitonic (sn_network_t *n0, /* {{{ */
623 return (sn_network_combine_bitonic_shift (n0, n1, /* do_shift = */ 0));
624 } /* }}} sn_network_t *sn_network_combine_bitonic */
626 sn_network_t *sn_network_combine_odd_even_merge (sn_network_t *n0, /* {{{ */
630 int indizes_left[n0->inputs_num];
631 int indizes_left_num;
632 int indizes_right[n1->inputs_num];
633 int indizes_right_num;
637 indizes_left_num = n0->inputs_num;
638 indizes_right_num = n1->inputs_num;
639 for (i = 0; i < indizes_left_num; i++)
641 for (i = 0; i < indizes_right_num; i++)
642 indizes_right[i] = indizes_left_num + i;
644 n = sn_network_concatenate (n0, n1);
648 status = sn_network_add_odd_even_merger (n,
649 indizes_left, indizes_left_num,
650 indizes_right, indizes_right_num);
653 sn_network_destroy (n);
657 sn_network_compress (n);
659 } /* }}} sn_network_t *sn_network_combine */
661 sn_network_t *sn_network_combine (sn_network_t *n0, /* {{{ */
662 sn_network_t *n1, int is_power_of_two)
666 if ((is_power_of_two != 0) && (sn_bounded_random (0, 9) == 0))
668 DPRINTF ("sn_network_combine: Using the bitonic merger.\n");
669 n = sn_network_combine_bitonic_shift (n0, n1, /* do_shift = */ 1);
673 DPRINTF ("sn_network_combine: Using the odd-even merger.\n");
674 n = sn_network_combine_odd_even_merge (n0, n1);
677 sn_network_compress (n);
680 } /* }}} sn_network_t *sn_network_combine */
682 int sn_network_sort (sn_network_t *n, int *values) /* {{{ */
688 for (i = 0; i < n->stages_num; i++)
690 status = sn_stage_sort (n->stages[i], values);
696 } /* }}} int sn_network_sort */
698 int sn_network_brute_force_check (sn_network_t *n) /* {{{ */
700 int test_pattern[n->inputs_num];
701 int values[n->inputs_num];
705 memset (test_pattern, 0, sizeof (test_pattern));
711 /* Copy the current pattern and let the network sort it */
712 memcpy (values, test_pattern, sizeof (values));
713 status = sn_network_sort (n, values);
717 /* Check if the array is now sorted. */
718 previous = values[0];
719 for (i = 1; i < n->inputs_num; i++)
721 if (previous > values[i])
723 previous = values[i];
726 /* Generate the next test pattern */
728 for (i = 0; i < n->inputs_num; i++)
730 if (test_pattern[i] == 0)
743 /* Break out of the while loop if we tested all possible patterns */
748 /* All tests successfull */
750 } /* }}} int sn_network_brute_force_check */
752 sn_network_t *sn_network_read (FILE *fh) /* {{{ */
759 while (fgets (buffer, sizeof (buffer), fh) != NULL)
761 char *str_key = buffer;
762 char *str_value = NULL;
763 int buffer_len = strlen (buffer);
765 while ((buffer_len > 0) && ((buffer[buffer_len - 1] == '\n')
766 || (buffer[buffer_len - 1] == '\r')))
769 buffer[buffer_len] = '\0';
774 str_value = strchr (buffer, ':');
775 if (str_value == NULL)
777 printf ("Cannot parse line: %s\n", buffer);
781 *str_value = '\0'; str_value++;
782 while ((*str_value != '\0') && (isspace (*str_value) != 0))
785 if (strcasecmp ("Inputs", str_key) == 0)
786 opt_inputs = atoi (str_value);
788 printf ("Unknown key: %s\n", str_key);
789 } /* while (fgets) */
794 n = sn_network_create (opt_inputs);
800 s = sn_stage_read (fh);
804 sn_network_stage_add (n, s);
807 if (SN_NETWORK_STAGE_NUM (n) < 1)
809 sn_network_destroy (n);
814 } /* }}} sn_network_t *sn_network_read */
816 sn_network_t *sn_network_read_file (const char *file) /* {{{ */
821 fh = fopen (file, "r");
825 n = sn_network_read (fh);
830 } /* }}} sn_network_t *sn_network_read_file */
832 int sn_network_write (sn_network_t *n, FILE *fh) /* {{{ */
836 fprintf (fh, "Inputs: %i\n", n->inputs_num);
839 for (i = 0; i < n->stages_num; i++)
840 sn_stage_write (n->stages[i], fh);
843 } /* }}} int sn_network_write */
845 int sn_network_write_file (sn_network_t *n, const char *file) /* {{{ */
850 fh = fopen (file, "w");
854 status = sn_network_write (n, fh);
859 } /* }}} int sn_network_write_file */
861 int sn_network_serialize (sn_network_t *n, char **ret_buffer, /* {{{ */
862 size_t *ret_buffer_size)
869 buffer = *ret_buffer;
870 buffer_size = *ret_buffer_size;
872 #define SNPRINTF_OR_FAIL(...) \
873 status = snprintf (buffer, buffer_size, __VA_ARGS__); \
874 if ((status < 1) || (status >= buffer_size)) \
877 buffer_size -= status;
879 SNPRINTF_OR_FAIL ("Inputs: %i\r\n\r\n", n->inputs_num);
881 for (i = 0; i < n->stages_num; i++)
883 status = sn_stage_serialize (n->stages[i], &buffer, &buffer_size);
888 *ret_buffer = buffer;
889 *ret_buffer_size = buffer_size;
891 } /* }}} int sn_network_serialize */
893 sn_network_t *sn_network_unserialize (char *buffer, /* {{{ */
899 if (buffer_size == 0)
902 /* Read options first */
903 while (buffer_size > 0)
912 endptr = strchr (buffer, '\n');
919 line_len = strlen (line);
921 if ((line_len > 0) && (line[line_len - 1] == '\r'))
923 line[line_len - 1] = 0;
931 str_value = strchr (line, ':');
932 if (str_value == NULL)
934 printf ("Cannot parse line: %s\n", line);
938 *str_value = '\0'; str_value++;
939 while ((*str_value != '\0') && (isspace (*str_value) != 0))
942 if (strcasecmp ("Inputs", str_key) == 0)
943 opt_inputs = atoi (str_value);
945 printf ("Unknown key: %s\n", str_key);
946 } /* while (fgets) */
951 n = sn_network_create (opt_inputs);
957 s = sn_stage_unserialize (&buffer, &buffer_size);
961 sn_network_stage_add (n, s);
964 if (SN_NETWORK_STAGE_NUM (n) < 1)
966 sn_network_destroy (n);
971 } /* }}} sn_network_t *sn_network_unserialize */
973 /* vim: set sw=2 sts=2 et fdm=marker : */