optimize push

src/sort/large_sort/large_sort.c

@@ -6,7 +6,7 @@
 /*   By: reasuke <[email protected]>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2024/01/22 16:55:10 by reasuke           #+#    #+#             */
-/*   Updated: 2024/02/12 18:33:50 by reasuke          ###   ########.fr       */
+/*   Updated: 2024/02/12 20:54:48 by reasuke          ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -45,7 +45,7 @@ void	large_sort(t_stack **p_a, t_stack **p_b)
 	if (size_a < 200)
 		_push_b_n_times(p_a, p_b, size_b);
 	else
-		push_b_segmented(p_a, p_b, size_b, 5);
+		push_b_segmented(p_a, p_b, size_b, 7);
 	nano_sort(p_a);
 	while (size_b--)
 	{

src/sort/large_sort/push_b_segmented.c

@@ -6,7 +6,7 @@
 /*   By: reasuke <[email protected]>       +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2024/02/11 22:57:28 by reasuke           #+#    #+#             */
-/*   Updated: 2024/02/12 18:32:39 by reasuke          ###   ########.fr       */
+/*   Updated: 2024/02/12 23:28:29 by reasuke          ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -28,56 +28,65 @@
 // [72, 96) -> [seg_size * 3, seg_size * 4)
 // [96, 123) -> [seg_size * 4, N)
 
-static int	_calc_segment_id(int pushed, int n, int num_seg)
+static int	_calc_segment_id(int target, int n, int segs)
 {
 	int	seg_size;
 	int	id;
 
-	if (num_seg <= 0)
+	if (segs <= 0)
 		return (-1);
-	seg_size = n / num_seg;
+	seg_size = n / segs;
 	id = 0;
-	while (id < num_seg)
+	while (id < segs)
 	{
-		if (id * seg_size <= pushed && pushed < (id + 1) * seg_size)
+		if (id * seg_size <= target && target < (id + 1) * seg_size)
 			return (id);
 		id++;
 	}
-	if (pushed >= seg_size * num_seg)
-		return (num_seg - 1);
+	if (target >= seg_size * segs)
+		return (segs - 1);
 	return (-1);
 }
 
 // ft_printf("ns: %d, index: %d, pushed: %d, n: %d\n", num_segment, index,
 // 	pushed, n);
-static bool	_should_push_b(int index, int pushed, int n, int num_seg)
+static bool	_should_push_b(int index, int pushed, int n, int segs)
 {
 	int	seg_size;
 	int	cur_id;
 	int	inf;
 	int	sup;
 
-	seg_size = n / num_seg;
-	cur_id = _calc_segment_id(pushed, n, num_seg);
-	inf = seg_size * cur_id;
-	sup = seg_size * (cur_id + 1);
-	if (cur_id == num_seg - 1)
-		sup = n;
+	seg_size = n / segs;
+	cur_id = _calc_segment_id(pushed, n, segs);
+	if (cur_id % 2 == 0)
+	{
+		inf = seg_size * cur_id;
+		sup = seg_size * (cur_id + 2);
+	}
+	else
+	{
+		inf = seg_size * (cur_id - 1);
+		sup = seg_size * (cur_id + 1);
+	}
+	if (cur_id == segs - 1)
+		return (inf < index && index <= n);
 	return (inf < index && index <= sup);
 }
 
-void	push_b_segmented(t_stack **p_a, t_stack **p_b, int n, int num_seg)
+void	push_b_segmented(t_stack **p_a, t_stack **p_b, int n, int segs)
 {
 	int	pushed;
+	int	index;
 
 	pushed = 0;
-	num_seg = 5;
 	while (pushed < n)
 	{
-		if (_should_push_b(get_content(*p_a)->index, pushed, n, num_seg))
+		index = get_content(*p_a)->index;
+		if (_should_push_b(index, pushed, n, segs))
 		{
 			operate_pb(p_a, p_b);
-			if (_calc_segment_id(pushed, n, num_seg) % 2 == 1)
+			if (_calc_segment_id(index - 1, n, segs) % 2 == 1)
 				operate_rb(p_b);
 			pushed++;
 		}

test/test_push_b_segmented.cpp

@@ -12,17 +12,15 @@ extern "C" {
 #include "push_swap.h"
 }
 
+__attribute__((unused)) static void put_void(void *p_content) {
+  t_content *c = static_cast<t_content *>(p_content);
+  std::cout << c->index << "\n";
+}
+
 static void segmented_test_main1() {
-  int N = 20;
-  std::vector<int> v(N);
-  for (int i = 0; i < N; ++i) {
-    v[i] = i + 1;
-  }
-  // shuffle vector
-  std::random_device seed_gen;
-  std::mt19937 engine(seed_gen());
-  std::shuffle(v.begin(), v.end(), engine);
-  int size_a = N;
+  std::vector<int> v = {9,  14, 18, 13, 12, 19, 2, 8,  16, 6,
+                        10, 17, 7,  1,  20, 15, 3, 11, 4,  5};
+  int size_a = v.size();
 
   t_stack *stack_a = NULL;
   t_stack *stack_b = NULL;
@@ -32,6 +30,7 @@ static void segmented_test_main1() {
   }
 
   push_b_segmented(&stack_a, &stack_b, size_a, 5);
+
   t_stack *st = stack_b;
   for (int i = 0; i < size_a; ++i) {
     if (i < 4) {
@@ -120,17 +119,17 @@ static void segmented_test_main2() {
 }
 
 TEST(push_b_segmented, case2) {
-  // save stdout
-  int stdout_copy = dup(STDOUT_FILENO);
-  // redirect stdout to /dev/null
-  int dev_null = open("/dev/null", O_WRONLY);
-  dup2(dev_null, 1);
-  close(dev_null);
+  // // save stdout
+  // int stdout_copy = dup(STDOUT_FILENO);
+  // // redirect stdout to /dev/null
+  // int dev_null = open("/dev/null", O_WRONLY);
+  // dup2(dev_null, 1);
+  // close(dev_null);
 
   // execute test
   segmented_test_main2();
 
-  // revert stdout
-  dup2(stdout_copy, STDOUT_FILENO);
-  close(stdout_copy);
-}
+  // // revert stdout
+  // dup2(stdout_copy, STDOUT_FILENO);
+  // close(stdout_copy);
+}