diff --git a/memory_replay/Alloc.cpp b/memory_replay/Alloc.cpp
index e97dca0..f776f0f 100644
--- a/memory_replay/Alloc.cpp
+++ b/memory_replay/Alloc.cpp
@@ -31,6 +31,7 @@
     case memory_trace::CALLOC:
     case memory_trace::MEMALIGN:
     case memory_trace::THREAD_DONE:
+    case memory_trace::UNKNOWN:
       return false;
 
     case memory_trace::FREE:
diff --git a/memory_replay/MemoryTrace.cpp b/memory_replay/MemoryTrace.cpp
index e6d21df..c080a07 100644
--- a/memory_replay/MemoryTrace.cpp
+++ b/memory_replay/MemoryTrace.cpp
@@ -141,8 +141,9 @@
       return "realloc";
     case THREAD_DONE:
       return "thread_done";
+    default:
+      return "unknown";
   }
-  return "unknown";
 }
 
 static size_t FormatEntry(const Entry& entry, char* buffer, size_t buffer_len) {
diff --git a/memory_replay/TraceBenchmark.cpp b/memory_replay/TraceBenchmark.cpp
index 1612997..dbc68c4 100644
--- a/memory_replay/TraceBenchmark.cpp
+++ b/memory_replay/TraceBenchmark.cpp
@@ -138,6 +138,7 @@
         }
         break;
       case memory_trace::THREAD_DONE:
+      case memory_trace::UNKNOWN:
         break;
     }
   }
@@ -239,6 +240,7 @@
         break;
 
       case memory_trace::THREAD_DONE:
+      case memory_trace::UNKNOWN:
         break;
     }
   }
diff --git a/memory_replay/VerifyTrace.cpp b/memory_replay/VerifyTrace.cpp
index 0094940..e60a213 100644
--- a/memory_replay/VerifyTrace.cpp
+++ b/memory_replay/VerifyTrace.cpp
@@ -129,6 +129,7 @@
         }
         break;
       case memory_trace::THREAD_DONE:
+      case memory_trace::UNKNOWN:
         break;
     }
 
diff --git a/memory_replay/include/memory_trace/MemoryTrace.h b/memory_replay/include/memory_trace/MemoryTrace.h
index 108a921..3b2a390 100644
--- a/memory_replay/include/memory_trace/MemoryTrace.h
+++ b/memory_replay/include/memory_trace/MemoryTrace.h
@@ -29,6 +29,7 @@
   REALLOC,
   FREE,
   THREAD_DONE,
+  UNKNOWN,
 };
 
 struct Entry {
diff --git a/memory_replay/main.cpp b/memory_replay/main.cpp
index 0f50953..ffa9773 100644
--- a/memory_replay/main.cpp
+++ b/memory_replay/main.cpp
@@ -47,6 +47,7 @@
   for (size_t i = 0; i < num_entries; i++) {
     switch (entries[i].type) {
       case memory_trace::THREAD_DONE:
+      case memory_trace::UNKNOWN:
         break;
       case memory_trace::MALLOC:
       case memory_trace::CALLOC:
diff --git a/profcollectd/binder/com/android/server/profcollect/IProfCollectd.aidl b/profcollectd/binder/com/android/server/profcollect/IProfCollectd.aidl
index 1476768..970c0fa 100644
--- a/profcollectd/binder/com/android/server/profcollect/IProfCollectd.aidl
+++ b/profcollectd/binder/com/android/server/profcollect/IProfCollectd.aidl
@@ -20,8 +20,6 @@
 
 /** {@hide} */
 interface IProfCollectd {
-    void schedule();
-    void terminate();
     void trace_system(@utf8InCpp String tag);
     void trace_process(@utf8InCpp String tag, @utf8InCpp String processes, float duration);
     void process();
diff --git a/profcollectd/libprofcollectd/lib.rs b/profcollectd/libprofcollectd/lib.rs
index 4663e68..741bed1 100644
--- a/profcollectd/libprofcollectd/lib.rs
+++ b/profcollectd/libprofcollectd/lib.rs
@@ -49,14 +49,12 @@
         if elapsed < TIMEOUT_TO_COLLECT_BOOT_PROFILE {
             trace_system("boot").map_err(err_to_binder_status)?;
         }
-        schedule().map_err(err_to_binder_status)?;
         Ok(())
     }
 }
 
-/// Initialise profcollectd service.
-/// * `schedule_now` - Immediately schedule collection after service is initialised.
-pub fn init_service(schedule_now: bool) -> Result<()> {
+/// Initialize profcollectd service.
+pub fn init_service() -> Result<()> {
     binder::ProcessState::start_thread_pool();
 
     let profcollect_binder_service = ProfcollectdBinderService::new()?;
@@ -67,13 +65,11 @@
     )
     .context("Failed to register service.")?;
 
-    if schedule_now {
-        let cb = BnProviderStatusCallback::new_binder(
-            ProviderStatusCallback { service_start_time: Instant::now() },
-            BinderFeatures::default(),
-        );
-        get_profcollectd_service()?.registerProviderStatusCallback(&cb)?;
-    }
+    let cb = BnProviderStatusCallback::new_binder(
+        ProviderStatusCallback { service_start_time: Instant::now() },
+        BinderFeatures::default(),
+    );
+    get_profcollectd_service()?.registerProviderStatusCallback(&cb)?;
 
     binder::ProcessState::join_thread_pool();
     Ok(())
@@ -84,18 +80,6 @@
         .context("Failed to get profcollectd binder service, is profcollectd running?")
 }
 
-/// Schedule periodic profile collection.
-pub fn schedule() -> Result<()> {
-    get_profcollectd_service()?.schedule()?;
-    Ok(())
-}
-
-/// Terminate periodic profile collection.
-pub fn terminate() -> Result<()> {
-    get_profcollectd_service()?.terminate()?;
-    Ok(())
-}
-
 /// Immediately schedule a one-off trace.
 pub fn trace_system(tag: &str) -> Result<()> {
     get_profcollectd_service()?.trace_system(tag)?;
diff --git a/profcollectd/libprofcollectd/scheduler.rs b/profcollectd/libprofcollectd/scheduler.rs
index e37ffe7..9229086 100644
--- a/profcollectd/libprofcollectd/scheduler.rs
+++ b/profcollectd/libprofcollectd/scheduler.rs
@@ -19,7 +19,6 @@
 use std::fs;
 use std::mem;
 use std::path::Path;
-use std::sync::mpsc::{sync_channel, SyncSender};
 use std::sync::Arc;
 use std::sync::Mutex;
 use std::thread;
@@ -27,12 +26,9 @@
 
 use crate::config::{get_sampling_period, Config, LOG_FILE, PROFILE_OUTPUT_DIR, TRACE_OUTPUT_DIR};
 use crate::trace_provider::{self, TraceProvider};
-use anyhow::{anyhow, ensure, Context, Result};
+use anyhow::{anyhow, Context, Result};
 
 pub struct Scheduler {
-    /// Signal to terminate the periodic collection worker thread, None if periodic collection is
-    /// not scheduled.
-    termination_ch: Option<SyncSender<()>>,
     /// The preferred trace provider for the system.
     trace_provider: Arc<Mutex<dyn TraceProvider + Send>>,
     provider_ready_callbacks: Arc<Mutex<Vec<Box<dyn FnOnce() + Send>>>>,
@@ -43,57 +39,11 @@
         let p = trace_provider::get_trace_provider()?;
         p.lock().map_err(|e| anyhow!(e.to_string()))?.set_log_file(&LOG_FILE);
         Ok(Scheduler {
-            termination_ch: None,
             trace_provider: p,
             provider_ready_callbacks: Arc::new(Mutex::new(Vec::new())),
         })
     }
 
-    fn is_scheduled(&self) -> bool {
-        self.termination_ch.is_some()
-    }
-
-    pub fn schedule_periodic(&mut self, config: &Config) -> Result<()> {
-        ensure!(!self.is_scheduled(), "Already scheduled.");
-
-        let (sender, receiver) = sync_channel(1);
-        self.termination_ch = Some(sender);
-
-        // Clone config and trace_provider ARC for the worker thread.
-        let config = config.clone();
-        let trace_provider = self.trace_provider.clone();
-
-        thread::spawn(move || {
-            loop {
-                match receiver.recv_timeout(config.collection_interval) {
-                    Ok(_) => break,
-                    Err(_) => {
-                        // Did not receive a termination signal, initiate trace event.
-                        if check_space_limit(&TRACE_OUTPUT_DIR, &config).unwrap() {
-                            trace_provider.lock().unwrap().trace_system(
-                                &TRACE_OUTPUT_DIR,
-                                "periodic",
-                                &get_sampling_period(),
-                                &config.binary_filter,
-                            );
-                        }
-                    }
-                }
-            }
-        });
-        Ok(())
-    }
-
-    pub fn terminate_periodic(&mut self) -> Result<()> {
-        self.termination_ch
-            .as_ref()
-            .ok_or_else(|| anyhow!("Not scheduled"))?
-            .send(())
-            .context("Scheduler worker disappeared.")?;
-        self.termination_ch = None;
-        Ok(())
-    }
-
     pub fn trace_system(&self, config: &Config, tag: &str) -> Result<()> {
         let trace_provider = self.trace_provider.clone();
         if check_space_limit(&TRACE_OUTPUT_DIR, config)? {
diff --git a/profcollectd/libprofcollectd/service.rs b/profcollectd/libprofcollectd/service.rs
index 5e3097a..49c5406 100644
--- a/profcollectd/libprofcollectd/service.rs
+++ b/profcollectd/libprofcollectd/service.rs
@@ -51,20 +51,6 @@
 impl binder::Interface for ProfcollectdBinderService {}
 
 impl IProfCollectd for ProfcollectdBinderService {
-    fn schedule(&self) -> BinderResult<()> {
-        let lock = &mut *self.lock();
-        lock.scheduler
-            .schedule_periodic(&lock.config)
-            .context("Failed to schedule collection.")
-            .map_err(err_to_binder_status)
-    }
-    fn terminate(&self) -> BinderResult<()> {
-        self.lock()
-            .scheduler
-            .terminate_periodic()
-            .context("Failed to terminate collection.")
-            .map_err(err_to_binder_status)
-    }
     fn trace_system(&self, tag: &str) -> BinderResult<()> {
         let lock = &mut *self.lock();
         lock.scheduler
diff --git a/profcollectd/profcollectctl.rs b/profcollectd/profcollectctl.rs
index bc22d3b..c533691 100644
--- a/profcollectd/profcollectctl.rs
+++ b/profcollectd/profcollectctl.rs
@@ -25,8 +25,6 @@
 Command to control profcollectd behaviour.
 
 command:
-    start       Schedule periodic collection.
-    stop        Terminate periodic collection.
     trace       Request an one-off system-wide trace.
     process     Convert traces to perf profiles.
     report      Create a report containing all profiles.
@@ -44,14 +42,6 @@
 
     let action = &args[1];
     match action.as_str() {
-        "start" => {
-            println!("Scheduling profile collection");
-            libprofcollectd::schedule().context("Failed to schedule collection.")?;
-        }
-        "stop" => {
-            println!("Terminating profile collection");
-            libprofcollectd::terminate().context("Failed to terminate collection.")?;
-        }
         "trace" => {
             println!("Performing system-wide trace");
             libprofcollectd::trace_system("manual").context("Failed to trace.")?;
diff --git a/profcollectd/profcollectd.rs b/profcollectd/profcollectd.rs
index 0c2e87d..3ae9121 100644
--- a/profcollectd/profcollectd.rs
+++ b/profcollectd/profcollectd.rs
@@ -22,7 +22,7 @@
 const HELP_MSG: &str = r#"
 profcollectd background daemon.
 usage: profcollectd [command]
-    nostart       Start daemon but do not schedule profile collection.
+    help       Print help message.
 "#;
 
 fn main() -> Result<()> {
@@ -33,12 +33,11 @@
         bail!("This program only takes one or no argument{}", &HELP_MSG);
     }
     if args.len() == 1 {
-        libprofcollectd::init_service(true)?;
+        libprofcollectd::init_service()?;
     }
 
     let action = &args[1];
     match action.as_str() {
-        "nostart" => libprofcollectd::init_service(false)?,
         "help" => println!("{}", &HELP_MSG),
         arg => bail!("Unknown argument: {}\n{}", &arg, &HELP_MSG),
     }