I don't understand why my code is slower in rust than JS I have also added multithreading in my rust code and not in my JS but Rust still slower.
extern crate rayon;
extern crate console;
#[macro_use]
extern crate lazy_static;
use rayon::prelude::*;
use std::sync::Mutex;
use console::style;
use std::fs;
use std::time::Instant;
use std::fs::File;
use std::io::Write;
use std::env;
mod terminal_render;
#[warn(unused_must_use)]
fn main() {
println!();
let now1 = Instant::now();
let mut vpn: Vec<String> = Vec::new();
terminal_render::set_loading(1,33.3,None);
let vpn_string = fs::read_to_string("VPN.txt").unwrap();
let mut normal: Vec<String> = Vec::new();
terminal_render::set_loading(1,66.6,None);
let normal_string = fs::read_to_string("NORMAL.txt").unwrap();
for x in vpn_string.split('\n') {
if x.len() >= 3 {
vpn.push(clear(x.trim().to_string()));
}
}
for x in normal_string.split('\n') {
if x.len() >= 3 {
normal.push(clear(x.trim().to_string()));
}
}
terminal_render::set_end(1,now1.elapsed().as_millis());
let now = Instant::now();
terminal_render::set_loading(0,0.0,None);
let bigger_vec: Mutex<Vec<String>> = Mutex::new(Vec::new());
let finished: Mutex<terminal_render::Type> = Mutex::new(terminal_render::Type::new(0));
let ln = vpn.len() as f32;
let lastp: Mutex<terminal_render::Type> = Mutex::new(terminal_render::Type::new(0));
vpn.par_iter().for_each(|p| {
let hu = input(p.to_string(),&normal_string);
let dat = filter(&hu,&vpn);
if let Ok(mut e) = bigger_vec.lock() {
e.extend(dat);
}
if let Ok(mut e) = finished.lock() {
e.tp += 1;
let y = (e.tp as f32)/ln * 100.0;
if let Ok(mut i) = lastp.lock() {
if i.tp < y as u32 {
terminal_render::set_loading(0,y,Some(temps_restant(&now,y)));
i.tp = y as u32;
}
}
}
});
terminal_render::set_end(0,now.elapsed().as_millis());
let now = Instant::now();
terminal_render::set_loading(2,0.0,None);
let o = format!("{:?}",filter(&bigger_vec.lock().unwrap(),&vpn));
terminal_render::set_loading(2,50.0,None);
let mut file = File::create("MODEL.txt").unwrap();
file.write_all(o.as_bytes()).unwrap();
terminal_render::set_end(2,now.elapsed().as_millis());
}
fn temps_restant(i: &Instant,p: f32) -> u32 {
let ela = (i.elapsed().as_millis()/100) as f32 / 10.0;
let time_pp = ela/p;
(time_pp*(100.0-p)) as u32
}
fn input(b: String, normal: &str) -> Vec<String> {
let mut dat: Vec<String> = Vec::with_capacity(b.len());
for x in 0..(b.len() - 3) {
for y in 3..b.len()-x {
let str = &b[x..(x+y)];
if normal.contains(str) {
continue;
}
dat.push(str.to_string());
}
}
dat
}
fn clear(e: String) -> String {
let mut i = String::new();
let p = "abcdefghijklmnopqrstuvwxyz0123456789. ";
for n in e.to_lowercase().split("") {
if p.contains(n) {
i.push_str(n);
}
}
i
}
fn filter(dat: &[String],vpn: &[String]) -> Vec<String> {
let mut gdat = Vec::with_capacity(dat.len());
for q in dat {
let mut count: u32 = 0;
for d in vpn {
if d.contains(q) {
count+=1;
}
}
if count > 1 {
gdat.push(q.to_string());
}
}
let mut lua: Vec<String> = Vec::new();
'loop3: for x in &gdat {
for y in &gdat {
if y.to_string().contains(x) {
continue 'loop3;
}
}
if !lua.contains(&x) {
lua.push(x.to_string());
}
}
lua
}
I think it is caused by the fors in the filter function.
And if you want the JS version:
function input(b,OKIp) {
var dat = [];
for (var x = 0; x < b.length; x++) {
if (x > b.length-2) {
continue;
}
var v = false;
for (var y = 1; y < b.length-x; y++) {
var str = b.substring(x,y);
if (y<4) {
continue;
}
for (var g of OKIp) {
if (g.includes(str)) {
v = true;
break;
}
}
if (v) {
continue;
}
dat.push(str);
}
}
return dat;
}
function filter(dat,VPNS) {
var gdat = [];
for (var q of dat) {
var count = 0;
for (var d of VPNS) {
if (d.includes(q)) {
count++;
}
}
if (count < 2) {
continue;
}
gdat.push([q,count]);
}
var lua = [];
for (var t of gdat) {
for (var y of gdat) {
if (y[0].includes(t[0])) {
t[0] = y[0];
}
}
if (!lua.includes(t[0])) {
lua.push(t[0]);
}
}
return lua;
}
function normalize(input) {
return input.toLowerCase().trim();
}
function train(VPN,NORMAL) {
var VPN1 = [];
var NORMAL1 = [];
for (var t of VPN) {
var f = normalize(t);
if (f.length > 2) {
VPN1.push(f);
}
}
for (var t of NORMAL) {
var f = normalize(t);
if (f.length > 2) {
NORMAL1.push(f);
}
}
var date = [];
var t = VPN1.length;
var t2 = 0.0;
for (var t1 of VPN1) {
for (var g of filter(input(t1,NORMAL1),VPN1)) {
date.push(g);
}
t2++;
console.log(t2/t*100.0);
}
return filter(date,VPN1)
}
function stringToList(str) {
var qa = [];
for (var ju of str.split("\n")) {
var t = ju.toLowerCase().replace("\r","").trim();
if (t.length>3) {
qa.push(t);
}
}
return qa;
}
var fs = require("fs");
var N = fs.readFileSync('NORMAL.txt', 'utf8');
var V = fs.readFileSync('VPN.txt', 'utf8');
console.time('Training on dataset');
var a = stringToList(V);
var b = stringToList(N);
console.log(train(a,b));
console.timeEnd('Training on dataset');
console.log("dataset size:",a.length,b.length)
If somebody can solve my problems.