Revert "Apple M1 compatibility (solana-labs#16346)"

This reverts commit 54a04ba.

README.md

@@ -32,12 +32,6 @@ $ sudo apt-get update
 $ sudo apt-get install libssl-dev libudev-dev pkg-config zlib1g-dev llvm clang make
 ```
 
-On Mac M1s, make sure you set up your terminal & homebrew [to use](https://5balloons.info/correct-way-to-install-and-use-homebrew-on-m1-macs/) Rosetta. You can install it with:
-
-```bash
-$ softwareupdate --install-rosetta
-```
-
 ## **2. Download the source code.**
 
 ```bash

core/src/banking_stage.rs

@@ -8,7 +8,7 @@ use lru::LruCache;
 use retain_mut::RetainMut;
 use solana_gossip::cluster_info::ClusterInfo;
 use solana_ledger::{blockstore_processor::TransactionStatusSender, entry::hash_transactions};
-use solana_measure::measure::Measure;
+use solana_measure::{measure::Measure, thread_mem_usage};
 use solana_metrics::{inc_new_counter_debug, inc_new_counter_info};
 use solana_perf::{
     cuda_runtime::PinnedVec,
@@ -259,6 +259,7 @@ impl BankingStage {
                 Builder::new()
                     .name("solana-banking-stage-tx".to_string())
                     .spawn(move || {
+                        thread_mem_usage::datapoint("solana-banking-stage-tx");
                         Self::process_loop(
                             my_pubkey,
                             &verified_receiver,

core/src/fetch_stage.rs

@@ -2,6 +2,7 @@
 
 use crate::banking_stage::HOLD_TRANSACTIONS_SLOT_OFFSET;
 use crate::result::{Error, Result};
+use solana_measure::thread_mem_usage;
 use solana_metrics::{inc_new_counter_debug, inc_new_counter_info};
 use solana_perf::packet::PacketsRecycler;
 use solana_perf::recycler::Recycler;
@@ -136,6 +137,7 @@ impl FetchStage {
         let fwd_thread_hdl = Builder::new()
             .name("solana-fetch-stage-fwd-rcvr".to_string())
             .spawn(move || loop {
+                thread_mem_usage::datapoint("solana-fetch-stage-fwd-rcvr");
                 if let Err(e) =
                     Self::handle_forwarded_packets(&forward_receiver, &sender, &poh_recorder)
                 {

core/src/replay_stage.rs

@@ -33,7 +33,7 @@ use solana_ledger::{
     entry::VerifyRecyclers,
     leader_schedule_cache::LeaderScheduleCache,
 };
-use solana_measure::measure::Measure;
+use solana_measure::{measure::Measure, thread_mem_usage};
 use solana_metrics::inc_new_counter_info;
 use solana_poh::poh_recorder::{PohRecorder, GRACE_TICKS_FACTOR, MAX_GRACE_SLOTS};
 use solana_rpc::{
@@ -367,11 +367,15 @@ impl ReplayStage {
                     last_print_time: Instant::now(),
                 };
                 loop {
+                    let allocated = thread_mem_usage::Allocatedp::default();
+
+                    thread_mem_usage::datapoint("solana-replay-stage");
                     // Stop getting entries if we get exit signal
                     if exit.load(Ordering::Relaxed) {
                         break;
                     }
 
+                    let start = allocated.get();
                     let mut generate_new_bank_forks_time =
                         Measure::start("generate_new_bank_forks_time");
                     Self::generate_new_bank_forks(
@@ -382,9 +386,11 @@ impl ReplayStage {
                         &mut progress,
                     );
                     generate_new_bank_forks_time.stop();
+                    Self::report_memory(&allocated, "generate_new_bank_forks", start);
 
                     let mut tpu_has_bank = poh_recorder.lock().unwrap().has_bank();
 
+                    let start = allocated.get();
                     let mut replay_active_banks_time = Measure::start("replay_active_banks_time");
                     let ancestors = bank_forks.read().unwrap().ancestors();
                     let descendants = bank_forks.read().unwrap().descendants().clone();
@@ -409,8 +415,11 @@ impl ReplayStage {
                         &cluster_slots_update_sender,
                     );
                     replay_active_banks_time.stop();
+                    Self::report_memory(&allocated, "replay_active_banks", start);
 
                     let forks_root = bank_forks.read().unwrap().root();
+                    let start = allocated.get();
+
                     // Reset any duplicate slots that have been confirmed
                     // by the network in anticipation of the confirmed version of
                     // the slot
@@ -525,6 +534,7 @@ impl ReplayStage {
                                                     );
                         }
                     }
+                    Self::report_memory(&allocated, "select_fork", start);
 
                     let mut select_vote_and_reset_forks_time =
                         Measure::start("select_vote_and_reset_forks");
@@ -564,6 +574,8 @@ impl ReplayStage {
                     }
                     heaviest_fork_failures_time.stop();
 
+                    let start = allocated.get();
+
                     let mut voting_time = Measure::start("voting_time");
                     // Vote on a fork
                     if let Some((ref vote_bank, ref switch_fork_decision)) = vote_bank {
@@ -607,6 +619,9 @@ impl ReplayStage {
                     };
                     voting_time.stop();
 
+                    Self::report_memory(&allocated, "votable_bank", start);
+                    let start = allocated.get();
+
                     let mut reset_bank_time = Measure::start("reset_bank");
                     // Reset onto a fork
                     if let Some(reset_bank) = reset_bank {
@@ -674,9 +689,12 @@ impl ReplayStage {
                                 }
                             }
                         }
+                        Self::report_memory(&allocated, "reset_bank", start);
                     }
                     reset_bank_time.stop();
+                    Self::report_memory(&allocated, "reset_bank", start);
 
+                    let start = allocated.get();
                     let mut start_leader_time = Measure::start("start_leader_time");
                     if !tpu_has_bank {
                         Self::maybe_start_leader(
@@ -702,6 +720,7 @@ impl ReplayStage {
                         }
                     }
                     start_leader_time.stop();
+                    Self::report_memory(&allocated, "start_leader", start);
 
                     let mut wait_receive_time = Measure::start("wait_receive_time");
                     if !did_complete_bank {
@@ -801,6 +820,17 @@ impl ReplayStage {
         (progress, heaviest_subtree_fork_choice)
     }
 
+    fn report_memory(
+        allocated: &solana_measure::thread_mem_usage::Allocatedp,
+        name: &'static str,
+        start: u64,
+    ) {
+        datapoint_debug!(
+            "replay_stage-memory",
+            (name, (allocated.get() - start) as i64, i64),
+        );
+    }
+
     #[allow(dead_code)]
     fn reset_duplicate_slots(
         duplicate_slots_reset_receiver: &DuplicateSlotsResetReceiver,

core/src/serve_repair.rs

@@ -21,7 +21,8 @@ use solana_ledger::{
     shred::{Nonce, Shred},
 };
 use solana_measure::measure::Measure;
-use solana_metrics::inc_new_counter_debug;
+use solana_measure::thread_mem_usage;
+use solana_metrics::{datapoint_debug, inc_new_counter_debug};
 use solana_perf::packet::{limited_deserialize, Packets, PacketsRecycler};
 use solana_sdk::{
     clock::Slot,
@@ -365,6 +366,7 @@ impl ServeRepair {
                         Self::report_reset_stats(&me, &mut stats);
                         last_print = Instant::now();
                     }
+                    thread_mem_usage::datapoint("solana-repair-listen");
                 }
             })
             .unwrap()
@@ -379,7 +381,9 @@ impl ServeRepair {
         stats: &mut ServeRepairStats,
     ) {
         // iter over the packets
+        let allocated = thread_mem_usage::Allocatedp::default();
         packets.packets.iter().for_each(|packet| {
+            let start = allocated.get();
             let from_addr = packet.meta.addr();
             limited_deserialize(&packet.data[..packet.meta.size])
                 .into_iter()
@@ -391,6 +395,10 @@ impl ServeRepair {
                         let _ignore_disconnect = response_sender.send(rsp);
                     }
                 });
+            datapoint_debug!(
+                "solana-serve-repair-memory",
+                ("serve_repair", (allocated.get() - start) as i64, i64),
+            );
         });
     }
 

crate-features/Cargo.toml

@@ -12,15 +12,14 @@ edition = "2018"
 [dependencies]
 backtrace = { version = "0.3.33", features = ["serialize-serde"] }
 bytes = { version = "0.4.12", features = ["either"] }
-cc = { version = "1.0.67", features = ["jobserver", "parallel"]}
+cc = { version = "1.0.45", features = ["jobserver", "num_cpus", "parallel"]}
 curve25519-dalek = { version = "2" }
 either= { version = "1.5.2" }
 lazy_static = { version = "1.4.0", features = ["spin", "spin_no_std"] }
 libc = { version = "0.2.62", features = ["extra_traits"] }
 rand_chacha = { version = "0.2.2" }
 regex-syntax = { version = "0.6.12" }
 reqwest = { version = "0.11.2", default-features = false, features = ["blocking", "rustls-tls", "json"] }
-ring = { version = "0.16.17" }
 serde = { version = "1.0.100", features = ["rc"] }
 ed25519-dalek = { version = "=1.0.1", features = ["serde"] }
 syn_0_15 = { package = "syn", version = "0.15.42", features = ["extra-traits", "fold", "full"] }

gossip/src/cluster_info.rs

@@ -39,7 +39,7 @@ use {
     rayon::{prelude::*, ThreadPool, ThreadPoolBuilder},
     serde::ser::Serialize,
     solana_ledger::shred::Shred,
-    solana_measure::measure::Measure,
+    solana_measure::{measure::Measure, thread_mem_usage},
     solana_metrics::{inc_new_counter_debug, inc_new_counter_error},
     solana_net_utils::{
         bind_common, bind_common_in_range, bind_in_range, find_available_port_in_range,
@@ -1699,6 +1699,7 @@ impl ClusterInfo {
                 let mut generate_pull_requests = true;
                 loop {
                     let start = timestamp();
+                    thread_mem_usage::datapoint("solana-gossip");
                     if self.contact_debug_interval != 0
                         && start - last_contact_info_trace > self.contact_debug_interval
                     {
@@ -2615,6 +2616,7 @@ impl ClusterInfo {
                             _ => error!("gossip run_listen failed: {}", err),
                         }
                     }
+                    thread_mem_usage::datapoint("solana-listen");
                 }
             })
             .unwrap()