`903438f`

performance optimiations: quicksort for tree children, hash based file lookups, binary search for file ops and state and change marking

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 6 months ago

SHA: 903438f56be4b60803ea39e79e1696faabc53a30
Parents: db4e112
Tree: 7d0e939

3 changed files

Status	File	+	-
M	`src/fuss_main.f90`	77	9
M	`src/git_module.f90`	209	25
M	`src/tree_module.f90`	73	46

src/fuss_main.f90modified

          call sort_tree(tree_root)
 -        ! Restore collapsed state to new tree
 +        ! Restore collapsed state to new tree (sort first for binary search optimization)
          if (n_collapsed > 0) then
 +            call quicksort_collapsed_paths(collapsed_paths, 1, n_collapsed)
              call restore_collapsed_state(tree_root, '', collapsed_paths, n_collapsed)
          end if
          deallocate(collapsed_paths)
          deallocate(temp_paths)
      end subroutine resize_path_array
 +    ! ========== Performance Optimization: Binary Search for Collapsed Paths ==========
 +    recursive subroutine quicksort_collapsed_paths(arr, low, high)
 +        character(len=512), intent(inout) :: arr(:)
 +        integer, intent(in) :: low, high
 +        integer :: pivot_idx
++
 +        if (low < high) then
 +            call partition_collapsed_paths(arr, low, high, pivot_idx)
 +            call quicksort_collapsed_paths(arr, low, pivot_idx - 1)
 +            call quicksort_collapsed_paths(arr, pivot_idx + 1, high)
 +        end if
 +    end subroutine quicksort_collapsed_paths
++
 +    subroutine partition_collapsed_paths(arr, low, high, pivot_idx)
 +        character(len=512), intent(inout) :: arr(:)
 +        integer, intent(in) :: low, high
 +        integer, intent(out) :: pivot_idx
 +        character(len=512) :: pivot, temp
 +        integer :: i, j
++
 +        pivot = trim(arr(high))
 +        i = low - 1
++
 +        do j = low, high - 1
 +            if (trim(arr(j)) <= pivot) then
 +                i = i + 1
 +                temp = arr(i)
 +                arr(i) = arr(j)
 +                arr(j) = temp
 +            end if
 +        end do
++
 +        temp = arr(i + 1)
 +        arr(i + 1) = arr(high)
 +        arr(high) = temp
++
 +        pivot_idx = i + 1
 +    end subroutine partition_collapsed_paths
++
 +    function binary_search_path(paths, n, target) result(index)
 +        character(len=512), intent(in) :: paths(:)
 +        integer, intent(in) :: n
 +        character(len=*), intent(in) :: target
 +        integer :: index
 +        integer :: low, high, mid
 +        character(len=512) :: target_trimmed, mid_val
++
 +        index = -1
 +        if (n == 0) return
++
 +        target_trimmed = trim(target)
 +        low = 1
 +        high = n
++
 +        do while (low <= high)
 +            mid = low + (high - low) / 2
 +            mid_val = trim(paths(mid))
++
 +            if (mid_val == target_trimmed) then
 +                index = mid
 +                return
 +            else if (mid_val < target_trimmed) then
 +                low = mid + 1
 +            else
 +                high = mid - 1
 +            end if
 +        end do
 +    end function binary_search_path
++
      recursive subroutine restore_collapsed_state(node, parent_path, collapsed_paths, n_collapsed)
          type(tree_node), pointer, intent(inout) :: node
          character(len=*), intent(in) :: parent_path
          integer, intent(in) :: n_collapsed
          type(tree_node), pointer :: child
          character(len=512) :: full_path
 -        integer :: i
 +        integer :: idx
          ! Build full path for this node
          if (len_trim(parent_path) == 0) then
              full_path = trim(parent_path) // '/' // trim(node%name)
          end if
 -        ! Check if this directory should be collapsed
 +        ! Check if this directory should be collapsed using binary search (O(log n) vs O(n))
          if (.not. node%is_file) then
 -            do i = 1, n_collapsed
 -                if (trim(collapsed_paths(i)) == trim(full_path)) then
 -                    node%is_expanded = .false.
 -                    exit
 -                end if
 -            end do
 +            idx = binary_search_path(collapsed_paths, n_collapsed, full_path)
 +            if (idx > 0) then
 +                node%is_expanded = .false.
 +            end if
          end if
          ! Recursively restore for children

src/git_module.f90modified

  contains
 +    ! ========== Performance Optimization: Binary Search Functions ==========
++
 +    recursive subroutine quicksort_files(arr, low, high)
 +        type(file_entry), intent(inout) :: arr(:)
 +        integer, intent(in) :: low, high
 +        integer :: pivot_idx
++
 +        if (low < high) then
 +            call partition_files(arr, low, high, pivot_idx)
 +            call quicksort_files(arr, low, pivot_idx - 1)
 +            call quicksort_files(arr, pivot_idx + 1, high)
 +        end if
 +    end subroutine quicksort_files
++
 +    subroutine partition_files(arr, low, high, pivot_idx)
 +        type(file_entry), intent(inout) :: arr(:)
 +        integer, intent(in) :: low, high
 +        integer, intent(out) :: pivot_idx
 +        character(len=512) :: pivot_path
 +        type(file_entry) :: temp
 +        integer :: i, j
++
 +        pivot_path = trim(arr(high)%path)
 +        i = low - 1
++
 +        do j = low, high - 1
 +            if (trim(arr(j)%path) <= pivot_path) then
 +                i = i + 1
 +                ! Swap arr(i) and arr(j)
 +                temp = arr(i)
 +                arr(i) = arr(j)
 +                arr(j) = temp
 +            end if
 +        end do
++
 +        ! Swap arr(i+1) and arr(high)
 +        temp = arr(i + 1)
 +        arr(i + 1) = arr(high)
 +        arr(high) = temp
++
 +        pivot_idx = i + 1
 +    end subroutine partition_files
++
 +    function binary_search_file(arr, n, target_path) result(index)
 +        type(file_entry), intent(in) :: arr(:)
 +        integer, intent(in) :: n
 +        character(len=*), intent(in) :: target_path
 +        integer :: index
 +        integer :: low, high, mid
 +        character(len=512) :: target_trimmed, mid_path
++
 +        index = -1  ! Not found
 +        if (n == 0) return
++
 +        target_trimmed = trim(target_path)
 +        low = 1
 +        high = n
++
 +        do while (low <= high)
 +            mid = low + (high - low) / 2
 +            mid_path = trim(arr(mid)%path)
++
 +            if (mid_path == target_trimmed) then
 +                index = mid
 +                return
 +            else if (mid_path < target_trimmed) then
 +                low = mid + 1
 +            else
 +                high = mid - 1
 +            end if
 +        end do
 +    end function binary_search_file
++
 +    ! ========== End Binary Search Functions ==========
++
++
      subroutine get_dirty_files(files, n_files)
          type(file_entry), allocatable, intent(out) :: files(:)
          integer, intent(out) :: n_files
          ! Copy to output array
          allocate(files(n_files))
 -        if (n_files > 0) files(1:n_files) = temp_files(1:n_files)
 +        if (n_files > 0) then
 +            files(1:n_files) = temp_files(1:n_files)
 +            ! Sort for binary search optimization
 +            call quicksort_files(files, 1, n_files)
 +        end if
          deallocate(temp_files)
      end subroutine get_dirty_files
                      call resize_array(temp_files, max_files)
                  end if
 -                ! Check if file is dirty and get status
 -                is_dirty_file = .false.
 +                ! Check if file is dirty and get status using binary search (O(log n) vs O(n))
 +                temp_files(n_files)%path = trim(line)
                  temp_files(n_files)%status = '  '  ! Initialize as clean
                  temp_files(n_files)%is_staged = .false.
                  temp_files(n_files)%is_unstaged = .false.
                  temp_files(n_files)%is_untracked = .false.
                  temp_files(n_files)%has_incoming = .false.
 -                do i = 1, n_dirty
 -                    if (trim(dirty_files(i)%path) == trim(line)) then
 -                        is_dirty_file = .true.
 -                        temp_files(n_files)%status = dirty_files(i)%status
 -                        temp_files(n_files)%is_staged = dirty_files(i)%is_staged
 -                        temp_files(n_files)%is_unstaged = dirty_files(i)%is_unstaged
 -                        temp_files(n_files)%is_untracked = dirty_files(i)%is_untracked
 -                        temp_files(n_files)%has_incoming = dirty_files(i)%has_incoming
 -                        exit
 -                    end if
 -                end do
 -                temp_files(n_files)%path = trim(line)
 +                i = binary_search_file(dirty_files, n_dirty, line)
 +                if (i > 0) then
 +                    ! Found in dirty files - copy status
 +                    temp_files(n_files)%status = dirty_files(i)%status
 +                    temp_files(n_files)%is_staged = dirty_files(i)%is_staged
 +                    temp_files(n_files)%is_unstaged = dirty_files(i)%is_unstaged
 +                    temp_files(n_files)%is_untracked = dirty_files(i)%is_untracked
 +                    temp_files(n_files)%has_incoming = dirty_files(i)%has_incoming
 +                end if
              end if
          end do
      subroutine mark_incoming_changes(files, n_files)
          type(file_entry), intent(inout) :: files(:)
          integer, intent(in) :: n_files
 -        integer :: iostat, unit_num, status_code, i
 +        integer :: iostat, unit_num, status_code, i, idx
          character(len=1024) :: line
 -        character(len=512) :: incoming_path
 +        character(len=512), allocatable :: incoming_paths(:)
 +        integer :: n_incoming, max_incoming
          ! Check if there's an upstream branch configured
          ! Don't prompt - this is called automatically during refresh
          open(newunit=unit_num, file='/tmp/fuss_incoming.txt', status='old', action='read', iostat=iostat)
          if (iostat /= 0) return
 +        ! Build sorted array of incoming file paths for binary search
 +        max_incoming = 100
 +        allocate(incoming_paths(max_incoming))
 +        n_incoming = 0
++
          do
              read(unit_num, '(A)', iostat=iostat) line
              if (iostat /= 0) exit
              if (len_trim(line) > 0) then
 -                incoming_path = trim(line)
 -                ! Mark this file as having incoming changes
 -                do i = 1, n_files
 -                    if (trim(files(i)%path) == trim(incoming_path)) then
 -                        files(i)%has_incoming = .true.
 -                        exit
 -                    end if
 -                end do
 +                n_incoming = n_incoming + 1
 +                if (n_incoming > max_incoming) then
 +                    ! Resize array
 +                    call resize_string_array(incoming_paths, max_incoming * 2)
 +                    max_incoming = max_incoming * 2
 +                end if
 +                incoming_paths(n_incoming) = trim(line)
              end if
          end do
          close(unit_num, status='delete')
++
 +        if (n_incoming == 0) then
 +            deallocate(incoming_paths)
 +            return
 +        end if
++
 +        ! Sort incoming paths for binary search
 +        call quicksort_strings(incoming_paths, 1, n_incoming)
++
 +        ! Use binary search to mark files with incoming changes (O(n log m) vs O(n×m))
 +        do i = 1, n_files
 +            idx = binary_search_string(incoming_paths, n_incoming, files(i)%path)
 +            if (idx > 0) then
 +                files(i)%has_incoming = .true.
 +            end if
 +        end do
++
 +        deallocate(incoming_paths)
      end subroutine mark_incoming_changes
 +    ! Helper subroutines for string array sorting and searching
 +    subroutine resize_string_array(array, new_size)
 +        character(len=512), allocatable, intent(inout) :: array(:)
 +        integer, intent(in) :: new_size
 +        character(len=512), allocatable :: temp(:)
 +        integer :: old_size
++
 +        old_size = size(array)
 +        allocate(temp(old_size))
 +        temp = array
 +        deallocate(array)
 +        allocate(array(new_size))
 +        array(1:old_size) = temp
 +        deallocate(temp)
 +    end subroutine resize_string_array
++
 +    recursive subroutine quicksort_strings(arr, low, high)
 +        character(len=512), intent(inout) :: arr(:)
 +        integer, intent(in) :: low, high
 +        integer :: pivot_idx
++
 +        if (low < high) then
 +            call partition_strings(arr, low, high, pivot_idx)
 +            call quicksort_strings(arr, low, pivot_idx - 1)
 +            call quicksort_strings(arr, pivot_idx + 1, high)
 +        end if
 +    end subroutine quicksort_strings
++
 +    subroutine partition_strings(arr, low, high, pivot_idx)
 +        character(len=512), intent(inout) :: arr(:)
 +        integer, intent(in) :: low, high
 +        integer, intent(out) :: pivot_idx
 +        character(len=512) :: pivot, temp
 +        integer :: i, j
++
 +        pivot = trim(arr(high))
 +        i = low - 1
++
 +        do j = low, high - 1
 +            if (trim(arr(j)) <= pivot) then
 +                i = i + 1
 +                temp = arr(i)
 +                arr(i) = arr(j)
 +                arr(j) = temp
 +            end if
 +        end do
++
 +        temp = arr(i + 1)
 +        arr(i + 1) = arr(high)
 +        arr(high) = temp
++
 +        pivot_idx = i + 1
 +    end subroutine partition_strings
++
 +    function binary_search_string(arr, n, target) result(index)
 +        character(len=512), intent(in) :: arr(:)
 +        integer, intent(in) :: n
 +        character(len=*), intent(in) :: target
 +        integer :: index
 +        integer :: low, high, mid
 +        character(len=512) :: target_trimmed, mid_val
++
 +        index = -1
 +        if (n == 0) return
++
 +        target_trimmed = trim(target)
 +        low = 1
 +        high = n
++
 +        do while (low <= high)
 +            mid = low + (high - low) / 2
 +            mid_val = trim(arr(mid))
++
 +            if (mid_val == target_trimmed) then
 +                index = mid
 +                return
 +            else if (mid_val < target_trimmed) then
 +                low = mid + 1
 +            else
 +                high = mid - 1
 +            end if
 +        end do
 +    end function binary_search_string
++
      subroutine git_fetch()
          integer :: status
          logical :: upstream_set

src/tree_module.f90modified

      use types_module
      implicit none
 +    ! Helper type for array of pointers
 +    type node_ptr
 +        type(tree_node), pointer :: ptr
 +    end type node_ptr
++
  contains
      recursive subroutine add_to_tree(node, path, is_staged, is_unstaged, is_untracked, has_incoming)
      subroutine sort_children(node)
          type(tree_node), pointer :: node
 -        type(tree_node), pointer :: sorted_head, sorted_tail
 -        type(tree_node), pointer :: current, next_node, insert_pos, prev
 -        logical :: inserted
 +        type(tree_node), pointer :: current
 +        type(node_ptr), allocatable :: children_array(:)
 +        integer :: count, i
          if (.not. associated(node%first_child)) return
          if (.not. associated(node%first_child%next_sibling)) return
 -        ! Build sorted list
 -        sorted_head => null()
 -        sorted_tail => null()
+-
 +        ! Count children
 +        count = 0
          current => node%first_child
          do while (associated(current))
 -            next_node => current%next_sibling
+-
 -            ! Insert current into sorted list
 -            if (.not. associated(sorted_head)) then
 -                ! First element
 -                sorted_head => current
 -                sorted_tail => current
 -                current%next_sibling => null()
 -            else
 -                ! Find insertion point
 -                inserted = .false.
 -                prev => null()
 -                insert_pos => sorted_head
+-
 -                do while (associated(insert_pos))
 -                    if (should_insert_before(current, insert_pos)) then
 -                        ! Insert before insert_pos
 -                        current%next_sibling => insert_pos
 -                        if (associated(prev)) then
 -                            prev%next_sibling => current
 -                        else
 -                            sorted_head => current
 -                        end if
 -                        inserted = .true.
 -                        exit
 -                    end if
 -                    prev => insert_pos
 -                    insert_pos => insert_pos%next_sibling
 -                end do
+-
 -                if (.not. inserted) then
 -                    ! Insert at end
 -                    sorted_tail%next_sibling => current
 -                    sorted_tail => current
 -                    current%next_sibling => null()
 -                end if
 -            end if
 +            count = count + 1
 +            current => current%next_sibling
 +        end do
++
 +        ! Allocate array of pointers
 +        allocate(children_array(count))
++
 +        ! Fill array with pointers to children
 +        current => node%first_child
 +        do i = 1, count
 +            children_array(i)%ptr => current
 +            current => current%next_sibling
 +        end do
++
 +        ! Sort the array using quicksort
 +        call quicksort_nodes(children_array, 1, count)
 -            current => next_node
 +        ! Rebuild linked list from sorted array
 +        node%first_child => children_array(1)%ptr
 +        do i = 1, count - 1
 +            children_array(i)%ptr%next_sibling => children_array(i + 1)%ptr
          end do
 +        children_array(count)%ptr%next_sibling => null()
 -        node%first_child => sorted_head
 +        deallocate(children_array)
      end subroutine sort_children
 +    recursive subroutine quicksort_nodes(arr, low, high)
 +        type(node_ptr), intent(inout) :: arr(:)
 +        integer, intent(in) :: low, high
 +        integer :: pivot_idx
++
 +        if (low < high) then
 +            call partition_nodes(arr, low, high, pivot_idx)
 +            call quicksort_nodes(arr, low, pivot_idx - 1)
 +            call quicksort_nodes(arr, pivot_idx + 1, high)
 +        end if
 +    end subroutine quicksort_nodes
++
 +    subroutine partition_nodes(arr, low, high, pivot_idx)
 +        type(node_ptr), intent(inout) :: arr(:)
 +        integer, intent(in) :: low, high
 +        integer, intent(out) :: pivot_idx
 +        type(tree_node), pointer :: pivot
 +        type(node_ptr) :: temp
 +        integer :: i, j
++
 +        pivot => arr(high)%ptr
 +        i = low - 1
++
 +        do j = low, high - 1
 +            if (trim(arr(j)%ptr%name) <= trim(pivot%name)) then
 +                i = i + 1
 +                ! Swap arr(i) and arr(j)
 +                temp = arr(i)
 +                arr(i) = arr(j)
 +                arr(j) = temp
 +            end if
 +        end do
++
 +        ! Swap arr(i+1) and arr(high)
 +        temp = arr(i + 1)
 +        arr(i + 1) = arr(high)
 +        arr(high) = temp
++
 +        pivot_idx = i + 1
 +    end subroutine partition_nodes
++
      function should_insert_before(a, b) result(before)
          type(tree_node), pointer, intent(in) :: a, b
          logical :: before