Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Adding a new node with authentication set - causes system_auth keyspace RF to be set to 1 #2129

Closed
slivne opened this issue Mar 3, 2017 · 17 comments
Assignees
Labels

Comments

@slivne
Copy link
Contributor

slivne commented Mar 3, 2017

Installation details
Scylla version (or git commit hash):
Cluster size:
OS (RHEL/CentOS/Ubuntu/AWS AMI):

It seems that we create system_auth tables when a new node boots up with RF=1 and then allow it to connect to the cluster.

Somehow the schema sync code - aligns on the schema the last node has created which has RF=1.

to reproduce

  1. create a cluster of 2 nodes)
  2. enable auth (in scylla.yaml insert authenticator: PasswordAuthenticator)
  3. boot cluster
  4. alter system_auth via cqlsh ALTER KEYSPACE "system_auth" WITH REPLICATION = { 'class' : 'SimpleStrategy', 'replication_factor' : 2 };
  5. verify via describe KEYSPACE system_auth;
  6. add a node (with authenticator: PasswordAuthenticator)
  7. run nodetool describecluster - the new node will not be synched
  8. enter with cqlsh - old node/new node and run describe KEYSPACE system_auth; - the old noewds should have RF=2 the added node RF=1
  9. wait for all nodes to synch on schema nodetool describecluster
  10. enter with cqlsh old node/new node - describe KEYSPACE system_auth; will show RF=1
@glommer
Copy link
Contributor

glommer commented Mar 4, 2017

FYI: Another user has just reported this on our public slack.

@tgrabiec
Copy link
Contributor

tgrabiec commented Mar 6, 2017

@slivne Schema sync works as expected, the latest change wins. Perhaps the problem is that we create the auth table before we do the sync with existing nodes?

@slivne
Copy link
Contributor Author

slivne commented Mar 6, 2017 via email

@tgrabiec
Copy link
Contributor

tgrabiec commented Mar 6, 2017

@slivne I am not able to reproduce. Do you have logs for that run?

@slivne
Copy link
Contributor Author

slivne commented Mar 6, 2017

scylla

~/scylla/build/release/scylla --version
666.development-0.20170227.e20b804

ccm create scylla-2 --scylla --vnodes -n 2 --install-dir=/home/shlomi/scylla-ccm/../scylla
 vi ~/.ccm/scylla-2/node1/conf/scylla.yaml 
 vi ~/.ccm/scylla-2/node2/conf/scylla.yaml 
 ccm node1 start --jvm_arg="--logger-log-level" --jvm_arg="migration_manager=trace" --jvm_arg="--logger-log-level" --jvm_arg="schema_tables=trace" --jvm_arg="--logger-log-level" --jvm_arg="storage_service=trace"
 ccm node2 start --jvm_arg="--logger-log-level" --jvm_arg="migration_manager=trace" --jvm_arg="--logger-log-level" --jvm_arg="schema_tables=trace" --jvm_arg="--logger-log-level" --jvm_arg="storage_service=trace"
 ccm node1 cqlsh -u cassandra -p cassandra
ALTER KEYSPACE "system_auth"    WITH REPLICATION = { 'class' : 'SimpleStrategy', 'replication_factor' : 2 };
describe KEYSPACE system_auth;

CREATE KEYSPACE system_auth WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '2'}  AND durable_writes = true;
.
.

 ccm add --scylla node3
 vi ~/.ccm/scylla-2/node3/conf/scylla.yaml 
 ccm node3 start --jvm_arg="--logger-log-level" --jvm_arg="migration_manager=trace" --jvm_arg="--logger-log-level" --jvm_arg="schema_tables=trace" --jvm_arg="--logger-log-level" --jvm_arg="storage_service=trace"
 ccm node1 cqlsh -u cassandra -p cassandra
describe KEYSPACE system_auth;

CREATE KEYSPACE system_auth WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '2'}  AND durable_writes = true;

.
.

 ccm node3 cqlsh -u cassandra -p cassandra
describe KEYSPACE system_auth;

CREATE KEYSPACE system_auth WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '1'}  AND durable_writes = true;

.
.
 ccm node1 nodetool describecluster
(wait till they are in synch)
 ccm node1 cqlsh -u cassandra -p cassandra
describe KEYSPACE system_auth;

CREATE KEYSPACE system_auth WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '1'}  AND durable_writes = true;
.
.
.

all_logs.tar.gz

@tgrabiec
Copy link
Contributor

tgrabiec commented Mar 6, 2017

@slivne In you logs on node3 I can see:

Bootstrap variables: 0 0 0 0

Which means auto_bootstrap is false, and that's the reason why node doesn't perform the schema sync.

@slivne
Copy link
Contributor Author

slivne commented Mar 6, 2017 via email

@slivne
Copy link
Contributor Author

slivne commented Mar 6, 2017

with auto_bootstrap: true -

the issue does not occur - so it seems there is no bug ....

ccm create scylla-2 --scylla --vnodes -n 2 --install-dir=/home/shlomi/scylla-ccm/../scylla
echo "authenticator: PasswordAuthenticator" >> ~/.ccm/scylla-2/node1/conf/scylla.yaml 
echo "authenticator: PasswordAuthenticator" >> ~/.ccm/scylla-2/node2/conf/scylla.yaml 
ccm node1 start --jvm_arg="--logger-log-level" --jvm_arg="migration_manager=trace" --jvm_arg="--logger-log-level" --jvm_arg="schema_tables=trace" --jvm_arg="--logger-log-level" --jvm_arg="storage_service=trace"
ccm node2 start --jvm_arg="--logger-log-level" --jvm_arg="migration_manager=trace" --jvm_arg="--logger-log-level" --jvm_arg="schema_tables=trace" --jvm_arg="--logger-log-level" --jvm_arg="storage_service=trace"
ccm node1 nodetool describecluster
ccm node1 cqlsh -u cassandra -p cassandra -e "ALTER KEYSPACE system_auth    WITH REPLICATION = { 'class' : 'SimpleStrategy', 'replication_factor' : 2 };"
ccm node1 cqlsh -u cassandra -p cassandra -e "describe keyspace system_auth"
ccm add --scylla node3 -b
echo "authenticator: PasswordAuthenticator" >> ~/.ccm/scylla-2/node3/conf/scylla.yaml 
ccm node3 start --jvm_arg="--logger-log-level" --jvm_arg="migration_manager=trace" --jvm_arg="--logger-log-level" --jvm_arg="schema_tables=trace" --jvm_arg="--logger-log-level" --jvm_arg="storage_service=trace"
ccm node1 cqlsh -u cassandra -p cassandra -e "describe keyspace system_auth"
while true 
do 
   ccm node3 cqlsh -u cassandra -p cassandra -e "describe keyspace system_auth"
   sleep 1
done

yet maybe the customer also started his node in this manner (the ami by default I think has it to false)

@slivne
Copy link
Contributor Author

slivne commented Mar 6, 2017

the customer is using the ami

  • by default the ami sets auto_bootstrap to false.
  • once the instance booted - they stopped the instance and changed the setting to be true - yet by that time it was to late.

I am checking if we have an ability in the ami to change the default bootstrap value.

@slivne
Copy link
Contributor Author

slivne commented Mar 6, 2017

so there is a way to start the ami tell it to have auto_bootstrap set to true

in the user data setting

--bootstrap

will change the default

https://github.com/scylladb/scylla-ami/blob/master/ds2_configure.py#L216

We need to update our documentation to reflect that

http://docs.scylladb.com/kb/add-nodes-on-ec2/

currently it only mentions seeds - we also need to specify bootstrap.

@glommer
Copy link
Contributor

glommer commented Mar 6, 2017 via email

@tzach
Copy link
Contributor

tzach commented Mar 6, 2017

I think the right way is to use an AMI parameter for not starting Scylla.
Then you can update the bootstrap, cluster name etc without affecting the running cluster.

@tgrabiec
Copy link
Contributor

tgrabiec commented Mar 6, 2017 via email

@tzach
Copy link
Contributor

tzach commented Mar 6, 2017

The generic add node does include cleanup
http://docs.scylladb.com/procedures/add_node_to_cluster/

KB section is out of date, and need to be revisited and moved under procedures.
https://github.com/scylladb/scylla-docs/issues/176

@nirmaayan FYI

@tgrabiec
Copy link
Contributor

tgrabiec commented Mar 6, 2017

The problem doesn't reproduce on Cassandra 2.2, because they create default keyspace metadata with timestamp=0, so it always looses with manual changes.

Since https://issues.apache.org/jira/browse/CASSANDRA-8853

@tgrabiec
Copy link
Contributor

tgrabiec commented Mar 7, 2017

Actually, it seems to be like that since 1.2.2 (https://issues.apache.org/jira/browse/CASSANDRA-5112)

@tgrabiec
Copy link
Contributor

tgrabiec commented Mar 7, 2017

Before we can apply a similar solution, we have to fix schema_tables::make_create_table_mutations() to not generate keyspace mutations using make_create_keyspace_mutations(), which generates keyspace mutations with current timestamp.

pdziepak pushed a commit that referenced this issue Mar 8, 2017
…ications

There is a workaround for notification race, which attaches keyspace
mutations to other schema changes in case the target node missed the
keyspace creation. Currently that generated keyspace mutations on the
spot instead of using the ones stored in schema tables. Those
mutations would have current timestamp, as if the keyspace has been
just modified. This is problematic because this may generate an
overwrite of keyspace parameters with newer timestamp but with stale
values, if the node is not up to date with keyspace metadata.

That's especially the case when booting up a node without enabling
auto_bootstrap. In such case the node will not wait for schema sync
before creating auth tables. Such table creation will attach
potentially out of date mutations for keyspace metadata, which may
overwrite changes made to keyspace paramteters made earlier in the
cluster.

Refs #2129.
pdziepak added a commit that referenced this issue Mar 8, 2017
…d tracing keyspaces" form Tomek

"If a node is bootstrapped with auto_boostrap disabled, it will not
wait for schema sync before creating global keyspaces for auth and
tracing. When such schema changes are then reconciled with schema on
other nodes, they may overwrite changes made by the user before the
node was started, because they will have higher timestamp.

To prevent that, let's use minimum timestamp so that default schema
always looses with manual modifications. This is what Cassandra does.

Fixes #2129."

* tag 'tgrabiec/prevent-keyspace-metadata-loss-v1' of github.com:scylladb/seastar-dev:
  db: Create default auth and tracing keyspaces using lowest timestamp
  migration_manager: Append actual keyspace mutations with schema notifications
avikivity pushed a commit that referenced this issue Mar 8, 2017
…d tracing keyspaces" form Tomek

"If a node is bootstrapped with auto_boostrap disabled, it will not
wait for schema sync before creating global keyspaces for auth and
tracing. When such schema changes are then reconciled with schema on
other nodes, they may overwrite changes made by the user before the
node was started, because they will have higher timestamp.

To prevent that, let's use minimum timestamp so that default schema
always looses with manual modifications. This is what Cassandra does.

Fixes #2129."

* tag 'tgrabiec/prevent-keyspace-metadata-loss-v1' of github.com:scylladb/seastar-dev:
  db: Create default auth and tracing keyspaces using lowest timestamp
  migration_manager: Append actual keyspace mutations with schema notifications

(cherry picked from commit 6db6d25)
tgrabiec pushed a commit that referenced this issue Mar 8, 2017
…d tracing keyspaces" form Tomek

"If a node is bootstrapped with auto_boostrap disabled, it will not
wait for schema sync before creating global keyspaces for auth and
tracing. When such schema changes are then reconciled with schema on
other nodes, they may overwrite changes made by the user before the
node was started, because they will have higher timestamp.

To prevent that, let's use minimum timestamp so that default schema
always looses with manual modifications. This is what Cassandra does.

Fixes #2129."

* tag 'tgrabiec/prevent-keyspace-metadata-loss-v1' of github.com:scylladb/seastar-dev:
  db: Create default auth and tracing keyspaces using lowest timestamp
  migration_manager: Append actual keyspace mutations with schema notifications

(cherry picked from commit 6db6d25)
kbr- pushed a commit to kbr-/scylla that referenced this issue Dec 16, 2021
…stamp

This was needed to fix issue scylladb#2129 which was only manifest itself with
auto_bootstrap set to false. The option is ignored now and we always
wait for schema to synch during boot.
kbr- pushed a commit to kbr-/scylla that referenced this issue Jan 7, 2022
…stamp

This was needed to fix issue scylladb#2129 which was only manifest itself with
auto_bootstrap set to false. The option is ignored now and we always
wait for schema to synch during boot.
kbr- pushed a commit to kbr-/scylla that referenced this issue Jan 8, 2022
…ions in `start()`

When creating internal distributed tables in
`system_distributed_keyspace::start()`, hardcoded timestamps were used.
This was to protect against issue scylladb#2129, where nodes would start without
synchronizing schema with the existing cluster, creating the tables
again, which would override any manual user changes to these tables.
The solution was to use small timestamps (like api::min_timestamp) - the
user-created schema mutations would always 'win' (because when they were
created, they used current time).

This workaround is no longer necessary: when nodes start they always
have to sync schema with existing nodes; we also don't allow
bootstrapping nodes in parallel.

When schema changes are performed by Raft group 0, certain constraints
are placed on the timestamps used for mutations. For this we'll need to
be able to use timestamps which are generated based on current time.
kbr- pushed a commit to kbr-/scylla that referenced this issue Jan 8, 2022
…ions in `start()`

When creating internal distributed tables in
`system_distributed_keyspace::start()`, hardcoded timestamps were used.
This was to protect against issue scylladb#2129, where nodes would start without
synchronizing schema with the existing cluster, creating the tables
again, which would override any manual user changes to these tables.
The solution was to use small timestamps (like api::min_timestamp) - the
user-created schema mutations would always 'win' (because when they were
created, they used current time).

This workaround is no longer necessary: when nodes start they always
have to sync schema with existing nodes; we also don't allow
bootstrapping nodes in parallel.

When schema changes are performed by Raft group 0, certain constraints
are placed on the timestamps used for mutations. For this we'll need to
be able to use timestamps which are generated based on current time.
nyh pushed a commit that referenced this issue Jan 12, 2022
…stamp

This was needed to fix issue #2129 which was only manifest itself with
auto_bootstrap set to false. The option is ignored now and we always
wait for schema to synch during boot.
kbr- pushed a commit to kbr-/scylla that referenced this issue Jan 13, 2022
…ions in `start()`

When creating internal distributed tables in
`system_distributed_keyspace::start()`, hardcoded timestamps were used.
This was to protect against issue scylladb#2129, where nodes would start without
synchronizing schema with the existing cluster, creating the tables
again, which would override any manual user changes to these tables.
The solution was to use small timestamps (like api::min_timestamp) - the
user-created schema mutations would always 'win' (because when they were
created, they used current time).

This workaround is no longer necessary: when nodes start they always
have to sync schema with existing nodes; we also don't allow
bootstrapping nodes in parallel.

When schema changes are performed by Raft group 0, certain constraints
are placed on the timestamps used for mutations. For this we'll need to
be able to use timestamps which are generated based on current time.
kbr- pushed a commit to kbr-/scylla that referenced this issue Jan 14, 2022
…ions in `start()`

When creating internal distributed tables in
`system_distributed_keyspace::start()`, hardcoded timestamps were used.
This was to protect against issue scylladb#2129, where nodes would start without
synchronizing schema with the existing cluster, creating the tables
again, which would override any manual user changes to these tables.
The solution was to use small timestamps (like api::min_timestamp) - the
user-created schema mutations would always 'win' (because when they were
created, they used current time).

This workaround is no longer necessary: when nodes start they always
have to sync schema with existing nodes; we also don't allow
bootstrapping nodes in parallel.

When schema changes are performed by Raft group 0, certain constraints
are placed on the timestamps used for mutations. For this we'll need to
be able to use timestamps which are generated based on current time.
kbr- pushed a commit to kbr-/scylla that referenced this issue Jan 17, 2022
…ions in `start()`

When creating or updating internal distributed tables in
`system_distributed_keyspace::start()`, hardcoded timestamps were used.

There two reasons for this:
- to protect against issue scylladb#2129, where nodes would start without
  synchronizing schema with the existing cluster, creating the tables
  again, which would override any manual user changes to these tables.
  The solution was to use small timestamps (like api::min_timestamp) - the
  user-created schema mutations would always 'win' (because when they were
  created, they used current time).
- to eliminate unnecessary schema sync. If two nodes created these
  tables concurrently with different timestamps, the schemas would
  formally be different and would need to merge. This could happen
  during upgrades when we upgraded from a version which doesn't have
  these tables or doesn't have some columns.

The scylladb#2129 workaround is no longer necessary: when nodes start they always
have to sync schema with existing nodes; we also don't allow
bootstrapping nodes in parallel.

The second problem would happen during parallel bootstrap, which we
don't allow, or during parallel upgrade. The procedure we recommend is
rolling upgrade - where nodes are upgraded one by one. In this case only
one node is going to create/update the tables; following upgraded nodes
will sync schema first and notice they don't need to do anything. So if
procedures are followed correctly, the workaround is not needed. If
someone doesn't follow the procedures and upgrades nodes in parallel,
these additional schema synchronizations are not a big cost, so the
workaround doesn't give us much in this case as well.

When schema changes are performed by Raft group 0, certain constraints
are placed on the timestamps used for mutations. For this we'll need to
be able to use timestamps which are generated based on current time.
kbr- pushed a commit to kbr-/scylla that referenced this issue Jan 18, 2022
…ions in `start()`

When creating or updating internal distributed tables in
`system_distributed_keyspace::start()`, hardcoded timestamps were used.

There two reasons for this:
- to protect against issue scylladb#2129, where nodes would start without
  synchronizing schema with the existing cluster, creating the tables
  again, which would override any manual user changes to these tables.
  The solution was to use small timestamps (like api::min_timestamp) - the
  user-created schema mutations would always 'win' (because when they were
  created, they used current time).
- to eliminate unnecessary schema sync. If two nodes created these
  tables concurrently with different timestamps, the schemas would
  formally be different and would need to merge. This could happen
  during upgrades when we upgraded from a version which doesn't have
  these tables or doesn't have some columns.

The scylladb#2129 workaround is no longer necessary: when nodes start they always
have to sync schema with existing nodes; we also don't allow
bootstrapping nodes in parallel.

The second problem would happen during parallel bootstrap, which we
don't allow, or during parallel upgrade. The procedure we recommend is
rolling upgrade - where nodes are upgraded one by one. In this case only
one node is going to create/update the tables; following upgraded nodes
will sync schema first and notice they don't need to do anything. So if
procedures are followed correctly, the workaround is not needed. If
someone doesn't follow the procedures and upgrades nodes in parallel,
these additional schema synchronizations are not a big cost, so the
workaround doesn't give us much in this case as well.

When schema changes are performed by Raft group 0, certain constraints
are placed on the timestamps used for mutations. For this we'll need to
be able to use timestamps which are generated based on current time.
kbr- pushed a commit to kbr-/scylla that referenced this issue Jan 24, 2022
…ions in `start()`

When creating or updating internal distributed tables in
`system_distributed_keyspace::start()`, hardcoded timestamps were used.

There two reasons for this:
- to protect against issue scylladb#2129, where nodes would start without
  synchronizing schema with the existing cluster, creating the tables
  again, which would override any manual user changes to these tables.
  The solution was to use small timestamps (like api::min_timestamp) - the
  user-created schema mutations would always 'win' (because when they were
  created, they used current time).
- to eliminate unnecessary schema sync. If two nodes created these
  tables concurrently with different timestamps, the schemas would
  formally be different and would need to merge. This could happen
  during upgrades when we upgraded from a version which doesn't have
  these tables or doesn't have some columns.

The scylladb#2129 workaround is no longer necessary: when nodes start they always
have to sync schema with existing nodes; we also don't allow
bootstrapping nodes in parallel.

The second problem would happen during parallel bootstrap, which we
don't allow, or during parallel upgrade. The procedure we recommend is
rolling upgrade - where nodes are upgraded one by one. In this case only
one node is going to create/update the tables; following upgraded nodes
will sync schema first and notice they don't need to do anything. So if
procedures are followed correctly, the workaround is not needed. If
someone doesn't follow the procedures and upgrades nodes in parallel,
these additional schema synchronizations are not a big cost, so the
workaround doesn't give us much in this case as well.

When schema changes are performed by Raft group 0, certain constraints
are placed on the timestamps used for mutations. For this we'll need to
be able to use timestamps which are generated based on current time.
syuu1228 pushed a commit to syuu1228/scylla that referenced this issue Jan 26, 2022
…ions in `start()`

When creating or updating internal distributed tables in
`system_distributed_keyspace::start()`, hardcoded timestamps were used.

There two reasons for this:
- to protect against issue scylladb#2129, where nodes would start without
  synchronizing schema with the existing cluster, creating the tables
  again, which would override any manual user changes to these tables.
  The solution was to use small timestamps (like api::min_timestamp) - the
  user-created schema mutations would always 'win' (because when they were
  created, they used current time).
- to eliminate unnecessary schema sync. If two nodes created these
  tables concurrently with different timestamps, the schemas would
  formally be different and would need to merge. This could happen
  during upgrades when we upgraded from a version which doesn't have
  these tables or doesn't have some columns.

The scylladb#2129 workaround is no longer necessary: when nodes start they always
have to sync schema with existing nodes; we also don't allow
bootstrapping nodes in parallel.

The second problem would happen during parallel bootstrap, which we
don't allow, or during parallel upgrade. The procedure we recommend is
rolling upgrade - where nodes are upgraded one by one. In this case only
one node is going to create/update the tables; following upgraded nodes
will sync schema first and notice they don't need to do anything. So if
procedures are followed correctly, the workaround is not needed. If
someone doesn't follow the procedures and upgrades nodes in parallel,
these additional schema synchronizations are not a big cost, so the
workaround doesn't give us much in this case as well.

When schema changes are performed by Raft group 0, certain constraints
are placed on the timestamps used for mutations. For this we'll need to
be able to use timestamps which are generated based on current time.
syuu1228 pushed a commit to syuu1228/scylla that referenced this issue Jan 26, 2022
…ions in `start()`

When creating or updating internal distributed tables in
`system_distributed_keyspace::start()`, hardcoded timestamps were used.

There two reasons for this:
- to protect against issue scylladb#2129, where nodes would start without
  synchronizing schema with the existing cluster, creating the tables
  again, which would override any manual user changes to these tables.
  The solution was to use small timestamps (like api::min_timestamp) - the
  user-created schema mutations would always 'win' (because when they were
  created, they used current time).
- to eliminate unnecessary schema sync. If two nodes created these
  tables concurrently with different timestamps, the schemas would
  formally be different and would need to merge. This could happen
  during upgrades when we upgraded from a version which doesn't have
  these tables or doesn't have some columns.

The scylladb#2129 workaround is no longer necessary: when nodes start they always
have to sync schema with existing nodes; we also don't allow
bootstrapping nodes in parallel.

The second problem would happen during parallel bootstrap, which we
don't allow, or during parallel upgrade. The procedure we recommend is
rolling upgrade - where nodes are upgraded one by one. In this case only
one node is going to create/update the tables; following upgraded nodes
will sync schema first and notice they don't need to do anything. So if
procedures are followed correctly, the workaround is not needed. If
someone doesn't follow the procedures and upgrades nodes in parallel,
these additional schema synchronizations are not a big cost, so the
workaround doesn't give us much in this case as well.

When schema changes are performed by Raft group 0, certain constraints
are placed on the timestamps used for mutations. For this we'll need to
be able to use timestamps which are generated based on current time.
benipeled pushed a commit to benipeled/scylla that referenced this issue May 31, 2022
Add a background fiber that works to free memory using spare cycles, so that
allocations don't have to evict cache synchronously. The shares for the fiber
are increased the closer we are to running out of memory, preferring to steal
cycles from the workload rather than encountering stalls.

The last patch is not strictly related but is a good idea.

See backport notes in the first patch. The others were trivial.

Test: unit (dev)

Ref scylladb#2113
Ref scylladb#2106
Ref scylladb#2071
Ref scylladb#2039

Closes scylladb#2129

* github.com:scylladb/scylla-enterprise:
  lsa: Mark compact_segment_locked() as noexcept
  lsa: Avoid excessive eviction if region is not compactible
  logalloc: fix quadratic behaviour of reclaim_from_evictable
  logalloc: reduce minimum lsa reserve in allocating_section to 1
  main: start background reclaim before bootstrap
  Merge 'lsa: background reclaim' from Avi Kivity
  logalloc: background reclaim
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Labels
Projects
None yet
Development

No branches or pull requests

4 participants