בקשת מידע | פיתוח הצופן התנכ"י

[משחזר מידע]

משו לא מובן

@trhtkgsh כתב בבקשת מידע | פיתוח הצופן התנכ"י:

ניסיתי בעזרת בינה מלאכותית ליצור פונקציה בC++ שמחפשת דילוגים ולקרוא לה בC#.

@trhtkgsh כתב בבקשת מידע | פיתוח הצופן התנכ"י:

הבעיה שלי שאני לא מצליח להגיע לרמת ביצועים גבוהה וחיפוש בצופן התנכ"י לוקח דקות ארוכות.

@trhtkgsh כתב בבקשת מידע | פיתוח הצופן התנכ"י:

אשמח לעזרה לכתיבת קוד בC++.

אם ניסית ולא עבד
מה יעזור עזרה?

[trhtkgsh]

@משחזר-מידע
1- כידוע בינה מלאכותית עדיין לא מוציאה תוצרים מסובכים יעילים.
2- אני יודע בוודאות שזה אפשרי כי התוכנות הקודמות של הצופן התנכ"י נכתבו בC++ וחיפוש אצלם מהיר (ברמה של שניה)

אני פשוט לא יודע להתעסק עם ניהול זיכרון ומצביעים בצורה טובה

[משחזר מידע]

@trhtkgsh כתב בבקשת מידע | פיתוח הצופן התנכ"י:

אני פשוט לא יודע להתעסק עם ניהול זיכרון ומצביעים בצורה טובה

סה"כ "*" ו"&"
לא מי יודע מה מסובך

[trhtkgsh]

@משחזר-מידע כתב בבקשת מידע | פיתוח הצופן התנכ"י:

@trhtkgsh כתב בבקשת מידע | פיתוח הצופן התנכ"י:

אני פשוט לא יודע להתעסק עם ניהול זיכרון ומצביעים בצורה טובה

סה"כ "*" ו"&"
לא מי יודע מה מסובך

אז אם זה לא כל כך מסובך בטח לא יהיה לך בעיה לכתוב לי את הקוד

[צדיק תמים]

@trhtkgsh כוונתו שאתה לא צריך "עזרה בכתיבה" כמו שכתבת בפוסט הפותח אלא שפשוט יכתבו את הקוד במקומך

@trhtkgsh כתב בבקשת מידע | פיתוח הצופן התנכ"י:

2- אני יודע בוודאות שזה אפשרי כי התוכנות הקודמות של הצופן התנכ"י נכתבו בC++ וחיפוש אצלם מהיר (ברמה של שניה)

זה לא בהכרח אומר שהפער המשמעותי היא השפה. יכול להיות שהאלגוריתם והמימוש שלהם יותר יעיל משלך (משום מה לא הבאת שום קוד קיים).

[yeo4]

עניינת. כמה רעיונות שעולים לי לראש:

1. איך אתה מבצע את החיפוש? בקוד בC#? או בSQL? (דהיינו קורא ממסד נתונים..)
2. חשבת אולי להפוך לחפש דרך "מנוע חיפוש" קיים שיש? מחיפוש מהיר ראיתי נגיד ספריית לוסין - שיש לה גם קוד של בC#.
3. עדיף לא להמציא את הגלגל מחדש.

כל טוב.

[trhtkgsh]

@צדיק-תמים
חשבתי שהייתי ברור.
אני צריך מתכנת C++ שיכתוב לי dll עם פונקציה שאפשר לקרוא לה בC#.
הפונקציה תקבל json של פרטי חיפוש ותחזיר תוצאות חיפוש בjson

לכתוב קוד שעובד הצלחתי.
לכתוב קוד שעובד יעיל לא הצלחתי.
אם רוצים אני יכול לתת את השלד של הקוד (קוד שעובד, אבל לא יעיל ברמה הרצויה)

[sivan22]

@trhtkgsh אתה צריך לחשוב קודם על אלגוריתם יעיל, לכתוב אותו אפילו בפסאודו קוד, ואז להחליט באיזו שפה כדאי לממש. אני ממש לא בטוח שניהול הזכרון הוא המפתח לחיפוש יעיל. קודם כדאי לבדוק בכיוון של אינדקסים וכדומה.

דרך אגב, אם אתה מחפש שפה יעילה במיוחד, היום משתמשים בRUST, היא מנהלת את הזכרון בצורה מיטבית ובלי הסיכונים הכרוכים בC++. החסרון היחיד שלה הוא עקומת למידה די תלולה.

[טופטופיסט]

@sivan22 כתב בבקשת מידע | פיתוח הצופן התנכ"י:

הסיכונים הכרוכים בC++

כמו מה למשל?

[trhtkgsh]

@sivan22 כתב בבקשת מידע | פיתוח הצופן התנכ"י:

@trhtkgsh אתה צריך לחשוב קודם על אלגוריתם יעיל, לכתוב אותו אפילו בפסאודו קוד, ואז להחליט באיזו שפה כדאי לממש. אני ממש לא בטוח שניהול הזכרון הוא המפתח לחיפוש יעיל. קודם כדאי לבדוק בכיוון של אינדקסים וכדומה.

אין אפשרות לחפש לפי אינדקסים, כי הטווח דינאמי (זה ליצור את האינדקסים כל פעם מחדש).
כיום אני מסנן את כל האותיות לפי הגדרה מסוימת.
הבעיה עם הצופן התנכ"י זה שצריך כל פעם לבדוק דילוגים מ-1 ועד 300,000 בפוטנציאל אם מחפשים בכל התורה

דרך אגב, אם אתה מחפש שפה יעילה במיוחד, היום משתמשים בRUST, היא מנהלת את הזכרון בצורה מיטבית ובלי הסיכונים הכרוכים בC++. החסרון היחיד שלה הוא עקומת למידה די תלולה.

ניסיתי לכתוב קוד ב-C# והמרתי אותו ל-C++ ורמת הביצועים השתפרה פלאים (במקום 10 לפחות לחיפוש זה ירד לדקה) והלוגיקה הייתה זהה.
האם לדעתך אפשר לקחת את הקוד הכי יעיל ב-C# ולהמיר אותו בבינה מלאכותית ל-Rust?
בחרתי ב-C++ כי הוא קרוב ל-C# ואפשר להבין אותו בקלות יחסית.

תודה, ומה אתה ממליץ?

יש לי קוד בסיסי שעובד:

#include "pch.h"
#include "Codes.h"
#include "CodeResult.h"
#include "CodesSearchSettings.h"

#include <future>
#include <nlohmann/json.hpp>
#include <Windows.h>

using json = nlohmann::json;

CodeResult* Codes::search(const char* settingsJson, int* resultCount)
{
	settings = Codes::initSettings(settingsJson);

	vector<future<vector<CodeResult>>> results;

	for (int i = settings->start; i <= settings->end; i++)
	{
		results.emplace_back(async(launch::async, [=]()->vector<CodeResult>
		{
			return logic(settings, i);
		}));
	}

	vector<CodeResult> finalResults;

	for (auto& task : results)
	{
		auto skippingResults = task.get();

		if (!skippingResults.empty())
			finalResults.insert(finalResults.end(), skippingResults.begin(), skippingResults.end());
	}

	*resultCount = finalResults.size();

	// Allocate memory using new
	CodeResult* resultArray = new CodeResult[*resultCount];

	// Copy the results to the allocated array
	std::copy(finalResults.begin(), finalResults.end(), resultArray);

	return resultArray;
}

CodesSearchSettings* Codes::initSettings(const char* settingsJson)
{
	std::string jsonDataString(settingsJson);
	json jsonData = json::parse(jsonDataString);

	CodesSearchSettings* newSettings = new CodesSearchSettings();

	newSettings->start = jsonData["Start"];
	newSettings->end = jsonData["End"];
	newSettings->lastIndex = jsonData["LastIndex"];
	newSettings->lettersCount = jsonData["LettersCount"];
	newSettings->searchTextLength = jsonData["SearchTextLength"];

	newSettings->searchText = new char[newSettings->searchTextLength + 1];
	strncpy_s(newSettings->searchText, newSettings->searchTextLength + 1, jsonData["SearchText"].get<string>().c_str(), _TRUNCATE);

	newSettings->lettersText = new char[newSettings->lettersCount + 1];
	strncpy_s(newSettings->lettersText, newSettings->lettersCount + 1, jsonData["LettersText"].get<string>().c_str(), _TRUNCATE);

	return newSettings;
}

vector<CodeResult> Codes::logic(CodesSearchSettings* settings, int skipping)
{
	vector<CodeResult> skippingResults;
	int totalLenth = settings->searchTextLength * skipping;

	for (int i = 0; i < settings->lastIndex; i++)
	{
		int index = 0;
		int lettersCounter = 0;

		for (int j = 0; j < totalLenth && i + j < settings->lettersCount; j += skipping)
		{
			char letterToCheck = settings->lettersText[i + j];
			char searchTextLetter = settings->searchText[index];

			if (searchTextLetter != letterToCheck)
				break;

			index++;
			lettersCounter++;
		}

		if (lettersCounter == settings->searchTextLength)
		{
			CodeResult result = { i, skipping };
			skippingResults.push_back(result);
		}
	}

	return skippingResults;
}

#define EXPORTED_METHOD extern "C" __declspec(dllexport)

EXPORTED_METHOD CodeResult* searchCodes(const char* settingsJson, int* resultCount)
{
	Codes codes;
	return codes.search(settingsJson, resultCount);
}

EXPORTED_METHOD void releaseMemory(CodeResult* resultArray) { delete[] resultArray; }

[sivan22]

@trhtkgsh לדעתי שווה לנסות להמיר לראסט, זה גם לא נראה קוד ארוך במיוחד. אבל תשתמש רק בקלוד סונט 3.5.

[trhtkgsh]

@sivan22
עדיך להשתמש ב- https://cursor.com/ שפונה לקלוד סונט 3.5.
תודה רבה, אנסה.
בכל מקרה אני מעדיף להשתמש ב-C++ כי יותר קל לתחזק אותו בפרויקט של כל התוכנה.
אז אם מישהו רוצה לעזור אשמח

[משחזר מידע]

@trhtkgsh כתב בבקשת מידע | פיתוח הצופן התנכ"י:

ניסיתי לכתוב קוד ב-C# והמרתי אותו ל-C++

המרת לdll?

[trhtkgsh]

@משחזר-מידע
כתבתי קוד ב-C#, המרתי אותו ל-C++. בניתי DLL של C++ וקראתי לו ב-C#.
רק זה שיפר את הביצועים באופן משמעותי.
ע"י AI הבנתי יותר שכדאי לשנות את סוג האובייקטים לשיפור ביצועים.
עדיין אין לי משהו טוב שעובד. כל הזמן תקלות שאני לא יודע איך לדבג C++.

[משחזר מידע]

@trhtkgsh
אתה מעלה כל התנך לזכרון מיד בהרצת התוכנה?
או כל חיפוש אתה מעלה מחדש?
או לא מעלה בכלל ומחפש בקובץ?

[trhtkgsh]

@משחזר-מידע
כל התנ"ך מועלה עם התוכנה וכל פסוק מכיל הרבה מידע עד לרמת האות.
וכך כל התנ"ך והמשנה (וכל טקסט אחר שיכניסו לתוכנה)

[משחזר מידע]

@trhtkgsh

דבר ראשון הייתי בודק איפה הזמן שלוקח
אם זה החיפוש עצמו
או אולי עוד לפני שהחיפוש מתחיל אם זה הקוד שלך או זמן הקריאה לdll וכו'

[trhtkgsh]

@משחזר-מידע
צוואר הבקבוק נמצא בחיפוש עצמו.
ניסיתי להחליף טיפוסים ומצביעים,
ניסיתי להריץ את כל החיפושים במקביל (את כל הטווח - 1,2,3,4....)
צריך להכיר את השפה ואת האוביקטים היעילים יותר ואת ניהול הזיכרון הטוב יותר כדי לשפר ביצועים.
לצערי אני לא מכיר את C++ ברמה הזו

[משחזר מידע]

@trhtkgsh
אני חושב בקול (לא ניסיתי)
אולי הבעיה (הזמן שלוקח) הוא בהמרה מאותיות עבריות
אולי חיפוש בhex ואולי אפי Bin (שלא צריך המרה) יהי יותר מהיר