496 lines
17 KiB
C++
496 lines
17 KiB
C++
#include <iostream>
|
|
#include <iterator>
|
|
#include <unordered_map>
|
|
#include <fstream>
|
|
#include <cstdio>
|
|
#include <vector>
|
|
#include <string>
|
|
#include <getopt.h>
|
|
#include <algorithm>
|
|
#include <iomanip>
|
|
#include <chrono>
|
|
#include <thread>
|
|
#include <filesystem>
|
|
#include <future>
|
|
#include <windows.h>
|
|
#include <mutex>
|
|
|
|
|
|
using namespace std;
|
|
using namespace std::chrono;
|
|
std::mutex cout_mutex;
|
|
|
|
const int BUFFER_SIZE = 2048;
|
|
|
|
// Helper function for Windows console cursor positioning
|
|
inline void set_cursor_position(int row, int col) {
|
|
HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
|
|
COORD pos;
|
|
pos.X = col - 1; // 0-based
|
|
pos.Y = row - 1; // 0-based
|
|
SetConsoleCursorPosition(hConsole, pos);
|
|
}
|
|
|
|
int get_console_width() {
|
|
CONSOLE_SCREEN_BUFFER_INFO csbi;
|
|
int columns = 80; // default
|
|
if (GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi)) {
|
|
columns = csbi.srWindow.Right - csbi.srWindow.Left + 1;
|
|
}
|
|
return columns;
|
|
}
|
|
|
|
inline string join(vector<string> const &strings, string delim)
|
|
{
|
|
stringstream ss;
|
|
string res = "";
|
|
copy(strings.begin(), strings.end(),
|
|
ostream_iterator<string>(ss, delim.c_str()));
|
|
|
|
res = ss.str();
|
|
res.pop_back();
|
|
return res;
|
|
}
|
|
|
|
inline vector<string> tokenize(string s, string delimiter = " ")
|
|
{
|
|
size_t pos_start = 0, pos_end, delim_len = delimiter.length();
|
|
string token;
|
|
vector<string> res;
|
|
|
|
while ((pos_end = s.find(delimiter, pos_start)) != string::npos) {
|
|
token = s.substr (pos_start, pos_end - pos_start);
|
|
pos_start = pos_end + delim_len;
|
|
res.push_back (token);
|
|
}
|
|
|
|
res.push_back (s.substr (pos_start));
|
|
|
|
return res;
|
|
}
|
|
|
|
int main(int argc, char** argv) {
|
|
system("cls");
|
|
|
|
ios::sync_with_stdio(false);
|
|
cin.tie(NULL);
|
|
|
|
//may return 0 when not able to detect
|
|
// const unsigned int max_thread_count = std::thread::hardware_concurrency();
|
|
// unsigned int thread_count = max_thread_count - 1;
|
|
|
|
string filename = "";
|
|
int append = 1;
|
|
int crush_all = 0;
|
|
int debug_mode = 0;
|
|
int allfiles = 0;
|
|
vector<string> testnames;
|
|
|
|
int c;
|
|
bool no_opt = true;
|
|
while ((c = getopt(argc, argv, "hf:ardt:x")) != -1) {
|
|
switch (c) {
|
|
case 'h':
|
|
cout << "Usage: " << argv[0] << " -f <filename> [-r <truncate>] [-t <testnames>] [-h]\n";
|
|
return 0;
|
|
case 'f':
|
|
filename = optarg;
|
|
break;
|
|
case 't':
|
|
optind--;
|
|
for( ;optind < argc && *argv[optind] != '-'; optind++){
|
|
testnames.push_back(argv[optind] );
|
|
}
|
|
break;
|
|
case 'a':
|
|
allfiles = 1;
|
|
break;
|
|
case 'r':
|
|
append = 0;
|
|
break;
|
|
case 'x':
|
|
crush_all = 1;
|
|
break;
|
|
case 'd':
|
|
debug_mode = 1;
|
|
break;
|
|
default:
|
|
cout << "Invalid option. Use -h for help.\n";
|
|
return 1;
|
|
}
|
|
no_opt = false;
|
|
}
|
|
|
|
if (no_opt == true) {
|
|
vector<string> prog_path = tokenize(argv[0], "\\");
|
|
string prog_name = prog_path.back();
|
|
cout << "\nUsage: " << prog_name << " -f <filename> [-r <truncate>] [-t <testnames>] [-h]\n";
|
|
|
|
cout << "\tOptions:\n";
|
|
cout << "\t\t-f => Specify .datalog file name\n";
|
|
cout << "\t\t-t => Specify tests to be extracted seprated by space\n";
|
|
cout << "\t\t-r => Truncate or replace generated files (default is append)\n";
|
|
cout << "\t\t-a => Process all .datalog files in current dir, overrides files specified in -f\n";
|
|
cout << "\t\t-x => Exract all tests, overrides tests specified in -t\n\n";
|
|
return 1;
|
|
}
|
|
|
|
vector<string> datalog_files;
|
|
|
|
if (allfiles == 1 && filename == "") {
|
|
namespace fs = std::filesystem;
|
|
for (const auto& entry : fs::directory_iterator(fs::current_path())) {
|
|
if (entry.is_regular_file() && entry.path().extension() == ".datalog") {
|
|
datalog_files.push_back(entry.path().string());
|
|
}
|
|
}
|
|
if (datalog_files.empty()) {
|
|
cerr << "No .datalog files found in current directory!\n";
|
|
return 1;
|
|
}
|
|
} else {
|
|
if (filename == "") {
|
|
cerr << "No .datalog file specified!\n";
|
|
return 1;
|
|
}
|
|
datalog_files.push_back(filename);
|
|
}
|
|
// You can now loop over datalog_files for processing
|
|
vector<std::future<void>> futures;
|
|
int file_num = 1;
|
|
auto time_start = steady_clock::now();
|
|
for (const auto& filename : datalog_files) {
|
|
int my_line = ++file_num;
|
|
|
|
futures.push_back(std::async(std::launch::async, [&, filename, my_line]() {
|
|
|
|
if (filename == "") {
|
|
return ;
|
|
}
|
|
|
|
unordered_map<string, int> has_header;
|
|
unordered_map<string, ofstream> FILE_HANDLE;
|
|
unordered_map<
|
|
string,
|
|
vector<vector<string>>
|
|
> hash_buff;
|
|
|
|
for(auto& name : testnames) {
|
|
has_header[name] = 0;
|
|
hash_buff[name].clear();
|
|
if (append == 1) {
|
|
FILE_HANDLE[name].open(name + ".csv", ios::app);
|
|
} else {
|
|
FILE_HANDLE[name].open(name + ".csv", ios::out | ios::trunc);
|
|
}
|
|
}
|
|
|
|
ifstream file_input;
|
|
|
|
file_input = ifstream(filename);
|
|
stringstream buffer;
|
|
buffer << file_input.rdbuf();
|
|
vector <string> m_vec_file;
|
|
m_vec_file = tokenize(buffer.str(), "\n");
|
|
|
|
|
|
if (!file_input) {
|
|
cerr << "Could not open input file!\n";
|
|
return ;
|
|
}
|
|
|
|
|
|
string testname = "";
|
|
string productname = "prodname";
|
|
string programrev = "99.99";
|
|
string operatorlotname = "operlotname";
|
|
string lotname = "0C00000";
|
|
string wafer = "99";
|
|
string temperature = "99";
|
|
string testsite;
|
|
string x_coord;
|
|
string y_coord;
|
|
|
|
unordered_map<string, int>
|
|
testcollookup = { {"TNAME", 9},
|
|
{"VCC", 10},
|
|
{"SUPPLIES", 11},
|
|
{"VALUE", 13},
|
|
{"INT", 14},
|
|
{"LOG_INT", 14},
|
|
{"RESULTS", 15},
|
|
{"PATTERN", 16},
|
|
{"STATE", 17},
|
|
{"NUM", 18},
|
|
{"CONDITION1", 19},
|
|
{"CONDITION2", 20},
|
|
{"CONDITION3", 21},
|
|
{"TEXT", 22}
|
|
};
|
|
int max_col = numeric_limits<int>::min();
|
|
for (const auto& value : testcollookup) {
|
|
if (value.second > max_col) {
|
|
max_col = value.second;
|
|
}
|
|
}
|
|
|
|
|
|
vector<string> testheader;
|
|
vector<string> testdetails;
|
|
|
|
string last_match;
|
|
string line;
|
|
|
|
|
|
|
|
long line_pos = 1;
|
|
long max_line_pos = m_vec_file.size();
|
|
|
|
string m_filename = (tokenize(filename, "\\")).back();
|
|
|
|
|
|
unsigned int part_size = m_vec_file.size() / 2; //thread_count;
|
|
// std::cout << "Part Size: " << part_size << " lines\n";
|
|
|
|
for (; part_size < m_vec_file.size(); ++part_size) {
|
|
vector<string> part_split_line;
|
|
string part_line = m_vec_file[part_size];
|
|
|
|
part_split_line = tokenize(part_line);
|
|
if (part_split_line[0] == "#START_DEVICE") {
|
|
break;
|
|
}
|
|
|
|
}
|
|
// std::cout << m_vec_file[part_size] << "\n";
|
|
for (unsigned int ctr = 0; ctr < m_vec_file.size(); ++ctr) {
|
|
line = m_vec_file[ctr];
|
|
if ((int(line_pos) % 100 == 0) || (line_pos == max_line_pos)) {
|
|
std::lock_guard<std::mutex> lock(cout_mutex); // Lock before updating console
|
|
|
|
int width = get_console_width();
|
|
std::ostringstream oss;
|
|
oss << " File: " << m_filename << " ";
|
|
std::string left = oss.str();
|
|
|
|
std::ostringstream progress_oss;
|
|
progress_oss << "[" << std::fixed << std::setprecision(3)
|
|
<< (100 * (float)line_pos / (float)max_line_pos) << "%]";
|
|
std::string right = progress_oss.str();
|
|
|
|
int padding = width - (int)left.length() - (int)right.length();
|
|
if (padding < 0) padding = 0;
|
|
|
|
set_cursor_position(my_line, 1);
|
|
std::cout << left << std::string(padding, ' ') << right << std::flush;
|
|
}
|
|
vector<string> split_line;
|
|
string match1 = "99";
|
|
string match2 = "99";
|
|
|
|
// istringstream iss(line);
|
|
// string word;
|
|
// while (iss >> word) split_line.push_back(word);
|
|
split_line = tokenize(line);
|
|
|
|
|
|
if (split_line.size()>0) {
|
|
match1 = split_line.at(0);
|
|
|
|
if (split_line.size()>1) {
|
|
match2 = split_line.at(1);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
if (match1 == "#PRODUCT") {
|
|
productname = match2;
|
|
last_match = "PRODUCT";
|
|
} else if (match1 == "#REV") {
|
|
programrev = match2;
|
|
last_match = "REV";
|
|
} else if (match1 == "#OPER_LOT_ID") {
|
|
operatorlotname = match2;
|
|
last_match = "OPER_LOT_ID";
|
|
} else if (match1 == "#LOT") {
|
|
if (match2 != "99") {
|
|
string lotname_temp = match2;
|
|
if (lotname_temp.length() > 6) {
|
|
lotname = lotname_temp.substr(0, 7);
|
|
} else {
|
|
lotname = lotname_temp;
|
|
}
|
|
last_match = "LOT";
|
|
}
|
|
} else if (match1 == "#WAFER") {
|
|
wafer = match2;
|
|
last_match = "WAFER";
|
|
} else if (match1 == "#LOTWAFER") {
|
|
vector<string> lotwafer_info = tokenize(match2, "_");
|
|
wafer = lotwafer_info.at(2);
|
|
lotname = lotwafer_info.at(1);
|
|
last_match = "LOTWAFER";
|
|
} else if (match1 == "#TEMP") {
|
|
temperature = match2;
|
|
last_match = "TEMP";
|
|
} else if (match1 == "#START_DEVICE") {
|
|
|
|
last_match = "START_DEVICE";
|
|
} else if (match1 == "#DIE_X") {
|
|
x_coord = match2;
|
|
last_match = "DIE_X";
|
|
} else if (match1 == "#DIE_Y") {
|
|
y_coord = match2;
|
|
last_match = "DIE_Y";
|
|
} else if (match1 == "#SITE") {
|
|
testsite = match2;
|
|
last_match = "SITE";
|
|
} else if (match1 == "TNAME") {
|
|
|
|
stringstream ss(line);
|
|
string word;
|
|
testheader.clear();
|
|
while (ss >> word) { // Extract word from the stream.
|
|
testheader.push_back(word);
|
|
}
|
|
|
|
|
|
last_match = "TNAME";
|
|
} else if (match1 == "bin_result") {
|
|
// cout << "[" << match1 << "]\n";
|
|
for ( auto &my_pair : hash_buff ) {
|
|
for (auto &m_arr : my_pair.second) {
|
|
m_arr.push_back(split_line.at(3));
|
|
m_arr.push_back(split_line.at(2));
|
|
}
|
|
|
|
|
|
}
|
|
} else if ( ( (crush_all == 1) && (match1!="TNAME") && (match1.size() > 0 && match1.at(0) != '#') ) || (find(testnames.begin(), testnames.end(), match1) != testnames.end()) ) {
|
|
|
|
stringstream ss(line);
|
|
string word;
|
|
testdetails.clear();
|
|
while (ss >> word) { // Extract word from the stream.
|
|
testdetails.push_back(word);
|
|
}
|
|
testname = testdetails[0];
|
|
|
|
vector<string> sub_buff;
|
|
|
|
for (int ctr = 0; ctr <= max_col; ++ctr) {
|
|
sub_buff.push_back(" ");
|
|
}
|
|
sub_buff[0] = productname;
|
|
sub_buff[1] = programrev;
|
|
sub_buff[2] = operatorlotname;
|
|
sub_buff[3] = lotname;
|
|
|
|
sub_buff[4] = wafer;
|
|
sub_buff[5] = x_coord;
|
|
sub_buff[6] = y_coord;
|
|
sub_buff[7] = testsite;
|
|
sub_buff[8] = temperature;
|
|
|
|
|
|
|
|
for (int i = 0; i <= (int)(testheader.size()-1); ++i) {
|
|
int index;
|
|
index = testcollookup[testheader[i]];
|
|
|
|
if (testheader[i] == "RESULTS") {
|
|
if (testdetails[i] == "PASS") {
|
|
sub_buff[index] = "1";
|
|
} else {
|
|
sub_buff[index] = "0";
|
|
}
|
|
} else {
|
|
sub_buff[index] = testdetails[i];
|
|
}
|
|
}
|
|
|
|
if (!debug_mode) {
|
|
hash_buff[testname].push_back(sub_buff);
|
|
}
|
|
|
|
|
|
} else if (match1 == "#END_DEVICE") {
|
|
if (!debug_mode) {
|
|
for ( auto &my_pair : hash_buff ) {
|
|
|
|
string test = my_pair.first;
|
|
string fileout = test + ".csv";
|
|
|
|
if (append ==1) {
|
|
|
|
ifstream infile(fileout);
|
|
if (infile.good())
|
|
{
|
|
string sLine;
|
|
|
|
getline(infile, sLine);
|
|
|
|
vector<string> sub_split_string = tokenize(sLine, ",");
|
|
if (sub_split_string.at(0) == "productname") {
|
|
has_header[test] = 1;
|
|
}
|
|
}
|
|
infile.close();
|
|
}
|
|
|
|
|
|
if (!has_header[test]) {
|
|
if (!FILE_HANDLE[test] .is_open()) {
|
|
if (append == 1) {
|
|
FILE_HANDLE[test].open(test + ".csv", ios::app);
|
|
} else {
|
|
FILE_HANDLE[test].open(test + ".csv", ios::out | ios::trunc);
|
|
}
|
|
}
|
|
|
|
FILE_HANDLE[test].seekp(0, ios::end);
|
|
if (FILE_HANDLE[test].tellp() == 0) {
|
|
FILE_HANDLE[test] << "productname,programrev,operatorlotname,lotname,wafer,x,y,testsite,temperature,testname,vcc,vccio,vccaux,testdoublevalue,testintvalue,testpass,pattern,state,intval,condition1,condition2,condition3,text,bin,binname\n";
|
|
}
|
|
}
|
|
|
|
for (auto &m_arr : hash_buff[test]) {
|
|
if (!FILE_HANDLE[test] .is_open()) {
|
|
FILE_HANDLE[test].open(test + ".csv", ios::app);
|
|
}
|
|
FILE_HANDLE[test] << join(m_arr,",") + "\n";
|
|
}
|
|
|
|
hash_buff[test].clear();
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
++line_pos;
|
|
}
|
|
|
|
|
|
for ( const auto &my_pair : hash_buff ) {
|
|
string test = my_pair.first;
|
|
// string fileout = test + ".csv";
|
|
|
|
// if (hash_buff[test].size() > 0) {
|
|
// FILE_HANDLE[test] << hash_buff[test];
|
|
// hash_buff[test].clear();
|
|
// }
|
|
|
|
FILE_HANDLE[test].close();
|
|
}
|
|
}));
|
|
}
|
|
|
|
|
|
|
|
for (auto& fut : futures) fut.get();
|
|
auto time_end = steady_clock::now();
|
|
cout << "\n\n\033[1;32m Finished: \033[0m" << duration_cast<milliseconds>(time_end - time_start).count() << " ms\n";
|
|
|
|
return 0;
|
|
} |