Skip to content

Commit

Permalink
Implement jj parallelize
Browse files Browse the repository at this point in the history
Parallelize revisions by making them siblings

Running `jj parallelize 1::2` will transform the history like this:
```text
3
|             3
2            / \
|    ->     1   2
1            \ /
|             0
0
```

Each of the target revisions is rebased onto the parents of the root(s) of
the target revset (not to be confused with the repo root). The children of
the head(s) of the target revset are rebased onto the target revisions.

The target revset is the union of the REVISIONS arguments.

The target revset being parallelized must satisfy several conditions,
otherwise the command will fail.

1. The heads of the target revset must not have different children.
2. The roots of the target revset must not have different parents.
3. The parents of all target revisions except the roots must also be
   parallelized. This means that the target revisions must be connected.
  • Loading branch information
emesterhazy committed Apr 5, 2024
1 parent 4b45dde commit 64e242a
Show file tree
Hide file tree
Showing 7 changed files with 899 additions and 0 deletions.
2 changes: 2 additions & 0 deletions CHANGELOG.md
Original file line number Diff line number Diff line change
Expand Up @@ -22,6 +22,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
* A new config option `ui.always-allow-large-revsets` has been added to
allow large revsets expressions in some commands, without the `all:` prefix.

* New command `jj parallelize` that rebases a set of revisions into siblings.

### Fixed bugs

## [0.16.0] - 2024-04-03
Expand Down
5 changes: 5 additions & 0 deletions cli/src/commands/mod.rs
Original file line number Diff line number Diff line change
Expand Up @@ -39,6 +39,7 @@ mod new;
mod next;
mod obslog;
mod operation;
mod parallelize;
mod prev;
mod rebase;
mod resolve;
Expand Down Expand Up @@ -114,6 +115,7 @@ enum Command {
#[command(subcommand)]
#[command(visible_alias = "op")]
Operation(operation::OperationCommand),
Parallelize(parallelize::ParallelizeArgs),
Prev(prev::PrevArgs),
Rebase(rebase::RebaseArgs),
Resolve(resolve::ResolveArgs),
Expand Down Expand Up @@ -180,6 +182,9 @@ pub fn run_command(ui: &mut Ui, command_helper: &CommandHelper) -> Result<(), Co
Command::Abandon(sub_args) => abandon::cmd_abandon(ui, command_helper, sub_args),
Command::Edit(sub_args) => edit::cmd_edit(ui, command_helper, sub_args),
Command::Next(sub_args) => next::cmd_next(ui, command_helper, sub_args),
Command::Parallelize(sub_args) => {
parallelize::cmd_parallelize(ui, command_helper, sub_args)
}
Command::Prev(sub_args) => prev::cmd_prev(ui, command_helper, sub_args),
Command::New(sub_args) => new::cmd_new(ui, command_helper, sub_args),
Command::Move(sub_args) => r#move::cmd_move(ui, command_helper, sub_args),
Expand Down
257 changes: 257 additions & 0 deletions cli/src/commands/parallelize.rs
Original file line number Diff line number Diff line change
@@ -0,0 +1,257 @@
// Copyright 2024 The Jujutsu Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

use std::collections::HashSet;
use std::io::Write;
use std::rc::Rc;

use indexmap::IndexSet;
use itertools::Itertools;
use jj_lib::backend::CommitId;
use jj_lib::commit::{Commit, CommitIteratorExt};
use jj_lib::repo::Repo;
use jj_lib::revset::{RevsetExpression, RevsetIteratorExt};
use tracing::instrument;

use crate::cli_util::{CommandHelper, RevisionArg};
use crate::command_error::{user_error, CommandError};
use crate::commands::rebase::rebase_descendants;
use crate::ui::Ui;

/// Parallelize revisions by making them siblings
///
/// Running `jj parallelize 1::2` will transform the history like this:
/// ```text
/// 3
/// | 3
/// 2 / \
/// | -> 1 2
/// 1 \ /
/// | 0
/// 0
/// ```
///
/// Each of the target revisions is rebased onto the parents of the root(s) of
/// the target revset (not to be confused with the repo root). The children of
/// the head(s) of the target revset are rebased onto the target revisions.
///
/// The target revset is the union of the REVISIONS arguments and must satisfy
/// several conditions, otherwise the command will fail.
///
/// 1. The heads of the target revset must have either the same children as the
/// other heads or none.
/// 2. The roots of the target revset have the same parents.
/// 3. The parents of all target revisions except the roots must also be
/// parallelized. This means that the target revisions must be connected.
#[derive(clap::Args, Clone, Debug)]
#[command(verbatim_doc_comment)]
pub(crate) struct ParallelizeArgs {
/// Revisions to parallelize
revisions: Vec<RevisionArg>,
}

#[instrument(skip_all)]
pub(crate) fn cmd_parallelize(
ui: &mut Ui,
command: &CommandHelper,
args: &ParallelizeArgs,
) -> Result<(), CommandError> {
let mut workspace_command = command.workspace_helper(ui)?;
// The target commits are the commits being parallelized. They are ordered
// here with parents before children.
let target_commits: Vec<Commit> = workspace_command
.parse_union_revsets(&args.revisions)?
.evaluate_to_commits()?
.try_collect()?;
if target_commits.len() < 2 {
writeln!(ui.status(), "Nothing changed.")?;
return Ok(());
}
workspace_command.check_rewritable(target_commits.iter().ids())?;

let mut tx = workspace_command.start_transaction();
let target_revset =
RevsetExpression::commits(target_commits.iter().ids().cloned().collect_vec());
let new_parents =
check_preconditions_and_get_new_parents(&target_revset, &target_commits, tx.repo())?;

// Rebase the non-target children of each target commit onto its new
// parents. A child which had a target commit as an ancestor before
// parallelize ran will have the target commit as a parent afterward.
for target_commit in target_commits.iter() {
// Children of the target commit, excluding other target commits.
let children: Vec<Commit> = RevsetExpression::commit(target_commit.id().clone())
.children()
.minus(&target_revset)
.evaluate_programmatic(tx.repo())?
.iter()
.commits(tx.repo().store())
.try_collect()?;
// These parents are shared by all children of the target commit and
// include the target commit itself plus any of its ancestors which are
// being parallelized.
let common_parents: IndexSet<Commit> = RevsetExpression::commit(target_commit.id().clone())
.ancestors()
.intersection(&target_revset)
.evaluate_programmatic(tx.repo())?
.iter()
.commits(tx.repo().store())
.try_collect()?;
for child in children {
let mut new_parents = common_parents.clone();
new_parents.extend(child.parents().into_iter());
rebase_descendants(
&mut tx,
command.settings(),
&new_parents.into_iter().collect_vec(),
&[child],
Default::default(),
)?;
}
}

// Rebase the target commits onto the parents of the root commit.
// We already checked that the roots have the same parents, so we can just
// use the first one.
let target_commits = target_commits
.into_iter()
// We need to reverse the iterator so that when we rebase the target
// commits they will appear in the same relative order in `jj log` that
// they were in before being parallelized. After reversing, the commits
// are ordered with children before parents.
.rev()
.collect_vec();
rebase_descendants(
&mut tx,
command.settings(),
&new_parents,
&target_commits,
Default::default(),
)?;

tx.finish(ui, format!("parallelize {} commits", target_commits.len()))
}

/// Returns the new parents of the parallelized commits or an error if any of
/// the following preconditions are not met:
///
/// 1. If the heads of the target revset must not have different children.
/// 2. The roots of the target revset must not have different parents.
/// 3. The parents of all target revisions except the roots must also be
/// parallelized. This means that the target revisions must be connected.
///
/// The `target_revset` must evaluate to the commits in `target_commits` when
/// the provided `repo` is used.
fn check_preconditions_and_get_new_parents(
target_revset: &Rc<RevsetExpression>,
target_commits: &[Commit],
repo: &dyn Repo,
) -> Result<Vec<Commit>, CommandError> {
check_target_heads(target_revset, repo)?;
let target_roots = check_target_roots(target_revset, repo)?;
check_target_commits_are_connected(&target_roots, target_commits)?;

// We already verified that the roots have the same parents, so we can just
// use the first root.
Ok(target_roots[0].parents())
}

/// Returns an error if the heads of the target revset have children which are
/// different.
fn check_target_heads(
target_revset: &Rc<RevsetExpression>,
repo: &dyn Repo,
) -> Result<(), CommandError> {
let target_heads = target_revset
.heads()
.evaluate_programmatic(repo)?
.iter()
.sorted()
.collect_vec();
if target_heads.len() == 1 {
return Ok(());
}
let all_children: Vec<Commit> = target_revset
.heads()
.children()
.evaluate_programmatic(repo)?
.iter()
.commits(repo.store())
.try_collect()?;
// Every child must have every target head as a parent, otherwise it means
// that the target heads have different children.
for child in all_children {
let parents = child.parent_ids().iter().sorted();
if !parents.eq(target_heads.iter()) {
return Err(user_error(
"All heads of the target revisions must have the same children.",
));
}
}
Ok(())
}

/// Returns the roots of the target revset or an error if their parents are
/// different.
fn check_target_roots(
target_revset: &Rc<RevsetExpression>,
repo: &dyn Repo,
) -> Result<Vec<Commit>, CommandError> {
let target_roots: Vec<Commit> = target_revset
.roots()
.evaluate_programmatic(repo)?
.iter()
.commits(repo.store())
.try_collect()?;
let expected_parents = target_roots[0].parent_ids().iter().sorted().collect_vec();
for root in target_roots[1..].iter() {
let root_parents = root.parent_ids().iter().sorted();
if !root_parents.eq(expected_parents.iter().copied()) {
return Err(user_error(
"All roots of the target revisions must have the same parents.",
));
}
}
Ok(target_roots)
}

/// The target commits must be connected. The parents of every target commit
/// except the root commit must also be target commits. Returns an error if this
/// requirement is not met.
fn check_target_commits_are_connected(
target_roots: &[Commit],
target_commits: &[Commit],
) -> Result<(), CommandError> {
let target_commit_ids: HashSet<CommitId> = target_commits.iter().ids().cloned().collect();
for target_commit in target_commits.iter() {
if target_roots.iter().ids().contains(target_commit.id()) {
continue;
}
for parent in target_commit.parent_ids() {
if !target_commit_ids.contains(parent) {
// We check this condition to return a more useful error to the user.
if target_commit.parent_ids().len() == 1 {
return Err(user_error(
"Cannot parallelize since the target revisions are not connected.",
));
}
return Err(user_error(
"Only the roots of the target revset are allowed to have parents which are \
not being parallelized.",
));
}
}
}
Ok(())
}
38 changes: 38 additions & 0 deletions cli/tests/cli-reference@.md.snap
Original file line number Diff line number Diff line change
Expand Up @@ -61,6 +61,7 @@ This document contains the help content for the `jj` command-line program.
* [`jj operation log`↴](#jj-operation-log)
* [`jj operation undo`↴](#jj-operation-undo)
* [`jj operation restore`↴](#jj-operation-restore)
* [`jj parallelize`↴](#jj-parallelize)
* [`jj prev`↴](#jj-prev)
* [`jj rebase`↴](#jj-rebase)
* [`jj resolve`↴](#jj-resolve)
Expand Down Expand Up @@ -126,6 +127,7 @@ To get started, see the tutorial at https://github.com/martinvonz/jj/blob/main/d
* `next`Move the working-copy commit to the child revision
* `obslog`Show how a change has evolved
* `operation`Commands for working with the operation log
* `parallelize`Parallelize revisions by making them siblings
* `prev`Move the working-copy commit to the parent revision
* `rebase`Move revisions to different parent(s)
* `resolve`Resolve a conflicted file with an external merge tool
Expand Down Expand Up @@ -1345,6 +1347,42 @@ This restores the repo to the state at the specified operation, effectively undo
## `jj parallelize`
Parallelize revisions by making them siblings
Running `jj parallelize 1::2` will transform the history like this:
```text
3
| 3
2 / \
| -> 1 2
1 \ /
| 0
0
```
Each of the target revisions is rebased onto the parents of the root(s) of
the target revset (not to be confused with the repo root). The children of
the head(s) of the target revset are rebased onto the target revisions.
The target revset is the union of the REVISIONS arguments and must satisfy
several conditions, otherwise the command will fail.
1. The heads of the target revset must have either the same children as the
other heads or none.
2. The roots of the target revset have the same parents.
3. The parents of all target revisions except the roots must also be
parallelized. This means that the target revisions must be connected.
**Usage:** `jj parallelize [REVISIONS]...`
###### **Arguments:**
* `<REVISIONS>` — Revisions to parallelize
## `jj prev`
Move the working-copy commit to the parent revision
Expand Down
1 change: 1 addition & 0 deletions cli/tests/runner.rs
Original file line number Diff line number Diff line change
Expand Up @@ -45,6 +45,7 @@ mod test_new_command;
mod test_next_prev_commands;
mod test_obslog_command;
mod test_operations;
mod test_parallelize_command;
mod test_rebase_command;
mod test_repo_change_report;
mod test_resolve_command;
Expand Down
6 changes: 6 additions & 0 deletions cli/tests/test_immutable_commits.rs
Original file line number Diff line number Diff line change
Expand Up @@ -184,6 +184,12 @@ fn test_rewrite_immutable_commands() {
Error: Commit 3d14df18607e is immutable
Hint: Configure the set of immutable commits via `revset-aliases.immutable_heads()`.
"###);
// parallelize
let stderr = test_env.jj_cmd_failure(&repo_path, &["parallelize", "description(b)", "main"]);
insta::assert_snapshot!(stderr, @r###"
Error: Commit 3d14df18607e is immutable
Hint: Configure the set of immutable commits via `revset-aliases.immutable_heads()`.
"###);
// rebase -s
let stderr = test_env.jj_cmd_failure(&repo_path, &["rebase", "-s=main", "-d=@"]);
insta::assert_snapshot!(stderr, @r###"
Expand Down
Loading

0 comments on commit 64e242a

Please sign in to comment.