Download loda-rust/rust_project/loda-rust-cli/src/analytics/analyze_instruction_constant.rs from Alignment-Lab-AI/ARC-stuff: direct link, hf CLI and curl.
- Browser
- Download file 7.59 kB
-
https://huggingface.co/datasets/Alignment-Lab-AI/ARC-stuff/resolve/main/loda-rust/rust_project/loda-rust-cli/src/analytics/analyze_instruction_constant.rs
- Command line
-
hf download hf://datasets/Alignment-Lab-AI/ARC-stuff/loda-rust/rust_project/loda-rust-cli/src/analytics/analyze_instruction_constant.rs
-
curl -L -o analyze_instruction_constant.rs https://huggingface.co/datasets/Alignment-Lab-AI/ARC-stuff/resolve/main/loda-rust/rust_project/loda-rust-cli/src/analytics/analyze_instruction_constant.rs
7.59 kB
| use super::{AnalyticsDirectory, BatchProgramAnalyzerPlugin, BatchProgramAnalyzerContext}; | |
| use crate::common::create_csv_file; | |
| use loda_rust_core; | |
| use loda_rust_core::parser::{Instruction, InstructionId, InstructionParameter, ParameterType, ParsedProgram}; | |
| use std::path::PathBuf; | |
| use std::error::Error; | |
| use std::collections::HashMap; | |
| use serde::Serialize; | |
| type HistogramKey = (InstructionId,i32); | |
| static DISCARD_EXTREME_VALUES_BEYOND_THIS_LIMIT: i64 = 10000; | |
| /// Creates a histogram about what constants goes with each instruction. | |
| /// | |
| /// The most used combo: `add $0,1` (addition by 1) and is used 38175 times. | |
| /// | |
| /// Almost as popular combo: `sub $0,1` (subtract by 1) and is used 35075 times. | |
| /// | |
| /// Less popular is the combo: `mul $0,-1` (multiply by -1) and is used 429 times. | |
| /// | |
| /// The majority of constants are only used a single time. | |
| /// | |
| /// Traverses all the programs inside the `loda-programs/oeis` dir. | |
| /// | |
| /// There are programs with unwanted huge magic constants. | |
| /// So too extreme values gets ignored. | |
| /// | |
| /// This outputs a `histogram_instruction_constant.csv` file, with this format: | |
| /// | |
| /// ```csv | |
| /// count;instruction;constant | |
| /// 532;add;1 | |
| /// 531;sub;1 | |
| /// 308;mov;1 | |
| /// 252;mul;2 | |
| /// 167;div;2 | |
| /// 137;mov;2 | |
| /// 121;add;2 | |
| /// 98;pow;2 | |
| /// 78;cmp;0 | |
| /// 69;bin;2 | |
| /// ``` | |
| pub struct AnalyzeInstructionConstant { | |
| analytics_directory: AnalyticsDirectory, | |
| histogram: HashMap<HistogramKey,u32>, | |
| number_of_constant_processed_unsuccessful: u32, | |
| number_of_constant_processed_successful: u32, | |
| } | |
| impl AnalyzeInstructionConstant { | |
| pub fn new(analytics_directory: AnalyticsDirectory) -> Self { | |
| Self { | |
| analytics_directory, | |
| histogram: HashMap::new(), | |
| number_of_constant_processed_unsuccessful: 0, | |
| number_of_constant_processed_successful: 0, | |
| } | |
| } | |
| fn analyze_inner(&mut self, program_id: u32, parsed_program: &ParsedProgram) { | |
| for instruction in &parsed_program.instruction_vec { | |
| if instruction.instruction_id == InstructionId::EvalSequence { | |
| continue; | |
| } | |
| if instruction.instruction_id == InstructionId::LoopBegin { | |
| continue; | |
| } | |
| if instruction.instruction_id == InstructionId::LoopEnd { | |
| continue; | |
| } | |
| if instruction.parameter_vec.len() != 2 { | |
| continue; | |
| } | |
| let source_parameter: &InstructionParameter = instruction.parameter_vec.last().unwrap(); | |
| if source_parameter.parameter_type != ParameterType::Constant { | |
| continue; | |
| } | |
| let value: i64 = source_parameter.parameter_value; | |
| let success: bool = self.analyze_instruction_and_constant(program_id, &instruction, value); | |
| if success { | |
| self.number_of_constant_processed_successful += 1; | |
| } else { | |
| self.number_of_constant_processed_unsuccessful += 1; | |
| } | |
| } | |
| } | |
| fn analyze_instruction_and_constant(&mut self, program_id: u32, instruction: &Instruction, raw_value: i64) -> bool { | |
| if raw_value.abs() > DISCARD_EXTREME_VALUES_BEYOND_THIS_LIMIT { | |
| debug!("program_id: {:?}, Ignoring too extreme constant: {:?}", program_id, raw_value); | |
| return false; | |
| } | |
| let value: i32 = raw_value as i32; | |
| if instruction.instruction_id == InstructionId::Add && value == 0 { | |
| debug!("program_id: {:?}, add by 0, can be eliminated", program_id); | |
| return false; | |
| } | |
| if instruction.instruction_id == InstructionId::Subtract && value == 0 { | |
| debug!("program_id: {:?}, subtract by 0, can be eliminated", program_id); | |
| return false; | |
| } | |
| if instruction.instruction_id == InstructionId::Multiply && value == 1 { | |
| debug!("program_id: {:?}, multiply by 1, can be eliminated", program_id); | |
| return false; | |
| } | |
| if instruction.instruction_id == InstructionId::Divide && value == 1 { | |
| debug!("program_id: {:?}, divide by 1, can be eliminated", program_id); | |
| return false; | |
| } | |
| if instruction.instruction_id == InstructionId::Divide && value == 0 { | |
| debug!("program_id: {:?}, detected a dangerous divide by 0", program_id); | |
| return false; | |
| } | |
| let key: HistogramKey = (instruction.instruction_id, value); | |
| let counter = self.histogram.entry(key).or_insert(0); | |
| *counter += 1; | |
| true | |
| } | |
| } | |
| impl BatchProgramAnalyzerPlugin for AnalyzeInstructionConstant { | |
| fn plugin_name(&self) -> &'static str { | |
| "AnalyzeInstructionConstant" | |
| } | |
| fn analyze(&mut self, context: &BatchProgramAnalyzerContext) -> Result<(), Box<dyn Error>> { | |
| self.analyze_inner(context.program_id, &context.parsed_program); | |
| Ok(()) | |
| } | |
| fn save(&self) -> Result<(), Box<dyn Error>> { | |
| let records: Vec<Record> = Record::sorted_records_from_histogram(&self.histogram); | |
| // Save as a CSV file | |
| let output_path: PathBuf = self.analytics_directory.histogram_instruction_constant_file(); | |
| create_csv_file(&records, &output_path) | |
| } | |
| fn human_readable_summary(&self) -> String { | |
| let rows: Vec<String> = vec![ | |
| format!("number of constants processed unsuccessful: {:?}", self.number_of_constant_processed_unsuccessful), | |
| format!("number of constants processed successful: {:?}", self.number_of_constant_processed_successful), | |
| format!("number of items in histogram: {:?}", self.histogram.len()) | |
| ]; | |
| rows.join("\n") | |
| } | |
| } | |
| struct Record { | |
| count: u32, | |
| instruction: String, | |
| constant: i32, | |
| } | |
| impl Record { | |
| fn sorted_records_from_histogram(histogram: &HashMap<HistogramKey,u32>) -> Vec<Record> { | |
| // Convert from dictionary to array | |
| let mut records = Vec::<Record>::new(); | |
| for (histogram_key, histogram_count) in histogram { | |
| let instruction_name: String = histogram_key.0.to_string(); | |
| let record = Record { | |
| count: *histogram_count, | |
| instruction: instruction_name, | |
| constant: histogram_key.1 | |
| }; | |
| records.push(record); | |
| } | |
| // Move the most frequently occuring items to the top | |
| // Move the lesser used items to the bottom | |
| records.sort_unstable_by_key(|item| (item.count, item.instruction.clone(), item.constant)); | |
| records.reverse(); | |
| records | |
| } | |
| } | |
| mod tests { | |
| use super::*; | |
| fn test_10000_sorted_records_from_histogram() { | |
| // Arrange | |
| let mut histogram: HashMap<HistogramKey,u32> = HashMap::new(); | |
| let key: HistogramKey = (InstructionId::Add, 42); | |
| histogram.insert(key, 1); | |
| let key: HistogramKey = (InstructionId::Multiply, 1337); | |
| histogram.insert(key, 3); | |
| let key: HistogramKey = (InstructionId::Subtract, 666); | |
| histogram.insert(key, 2); | |
| // Act | |
| let records: Vec<Record> = Record::sorted_records_from_histogram(&histogram); | |
| // Assert | |
| let expected: Vec<Record> = vec![ | |
| Record { count: 3, instruction: "mul".to_string(), constant: 1337 }, | |
| Record { count: 2, instruction: "sub".to_string(), constant: 666 }, | |
| Record { count: 1, instruction: "add".to_string(), constant: 42 }, | |
| ]; | |
| assert_eq!(records, expected); | |
| } | |
| } | |