#dev (ilita) | Обсуждение разработки I2Pd | i2pd development discussion | http://i2pd.website/

weko R4SAS: так когда человеку прочитать надо, тогда и форматировать. А вообще, сейчас один хер читаемость, а позже тоже один хер будет, когда будет много параметров

R4SAS orignal: если писать плоское хранилище, в любом случае придется считывать весь файл

R4SAS даже если мы сейчас заменим папки на файлы то всё равно их придется считывать

weko [16:22:57] <R4SAS> ну так предлагай

weko [16:23:05] <R4SAS> без внешних зависимостей

weko Ну название NetDb оправдывает зависимость хотя бы от простецкой DB. Но если изобретать велосипед - то по сути нам нужна хэш таблица в файле

R4SAS не знаю как работает sqlite в этом плане

weko Чтобы зная RI можно было узнать точный байт начала нужной нам записи

weko Ну я тоже хз

weko Но основная суть что хэш таблица в файле нужна

R4SAS weko: понятное дело. а потом, перезапись всего файла ведь

R4SAS а эта таблица будет расти

R4SAS и уменьшаться

weko R4SAS: ну да, перезапись файла. Всяко лучше чем тысячи файлов

weko Чтобы новое поле добавить нужно будет версию поменять, чтобы пересоздать файл с другим количеством данных

weko Ну ещё можно два файла - в одном хэш таблица с ссылками на второй файл, а во второй -сами данные

weko Тогда мерезаписывать надо будет не так уж много

R4SAS вообще, сейчас hagen написать то написал, но вот для начала надо эту тонну старых файлов мигрировать на новый формат. а вот этого он не учел)))

weko Ага...

weko Лучше перенести. А то мало ли какой ад после релиза будет

R4SAS я тоже думаю что надо два файла делать

R4SAS толко не хеш таблица, а просто список доступных записей

weko Первый - хэш таблица ссылок (адресами начала данных), а во втором сами данные

weko Правда второй придётся делать аля FS

orignal ну так знаю

weko R4SAS: а как за O(1) искать?

R4SAS вообще есть такой вариант: а что если действительно писать так:

orignal вот и не надо плоское

R4SAS файл 1: index.list

orignal надо допустим по первым двум буква base64

weko Ну или куча

R4SAS файл 2: сами данные

weko orignal: часть работы дилегировать файловое системе, часть нам?

orignal ага

weko orignal: 4096 файлов будет

weko При чём всегда

orignal ну да

R4SAS в первом хранятся сами base64 в алфавитном или не очень, порядке. во втором base64 + данные

orignal не так много

R4SAS строка в строку

weko R4SAS: а как за O(1) искать или хотя бы O(log n)?

R4SAS индекс (номер строки) первого файла должен совпадать с номером строки в втором

R4SAS а при работе с данными уже читать не весь файл, а только конкретную строку

weko Поиск должен быть константным, потому что его очень много

R4SAS weko: не понял вопроса

weko Ну чтобы не грузить весь файл и искать за O(1)

weko А или типо мы первый файл грузим, делаем хэш таблицу, потом по ней что нужно ищем?

R4SAS крч всегда придется держать файл в памяти

R4SAS weko: да

weko А во втором файле как быстро находить если мы его не загружаем?

weko Не, не решает проблемы

weko Чтобы не грузить всё сразу нужно сам файл делать хэш таблицей

R4SAS ты в любом случае будешь грузить всё сразу

R4SAS ты открываешь файл, а далее как ты перейдешь чисто в нужное место?

weko Ну найду в хэш таблице начало данных

weko И начну читать с этого начала

R4SAS тогда надо хранить не только позицию начала, но и длину

weko Там можно первые 4 байта длину хранить, ровно по этой длине читаем

weko Ну понятно

R4SAS и в конце должна быть какая та завершающая последовательность для проверки валидности

weko А зачем

weko Если длина есть?

weko Хэш сумму можно

weko CRC например

R4SAS а если ты например ручками файлик решишь подредактировать, длина записи изменится и потом считывая запись получится так что либо данные не дочитались, либо прочитаны сверх нормы

R4SAS то что тогда?

weko "Сам дурак" :)

R4SAS вот именно

weko Будет уроком люботным варварам

R4SAS только полетит всё база

R4SAS а не конкретная запись

weko ну CRC надо

weko И вот orignal предлагает 4096 файлов сделать

R4SAS поэтому хеш таблица с позициями начала тоже такое себе

R4SAS почему 4096?

weko Потому что первые две буквы base64

R4SAS а зачем две то?

weko Не знаю

weko Можно одну

R4SAS вообще, это еще от системы зависить будет

weko Да...

weko Проблема

R4SAS вод линями будет 64, а вот под винде похер на это, и будет только 38

R4SAS под*

weko Где то FS оптимально работает (лучше чем i2pd), а где-то i2pd будет значительно быстрее в 64 файлах работать например

weko R4SAS: почему 38?

R4SAS я скажу сразу - фс ни где не работает оптимально

R4SAS когда файлов тысячи

weko Значит 64 файла заебись?

orignal комбинации первых двух букв

weko Или как

weko orignal: ну вот крыл говорит не оптимально

R4SAS потому что винда насрала на капитализацию

orignal 4096 даже в досе не было проблемой

R4SAS F = f

orignal вспомните цивилизаци.

weko R4SAS: значит нейминг хитрый сделать

weko f = f, F = *F

weko Типо такого

R4SAS а нахера?

weko Большие буквы писать как две

weko Так чтобы везде работало

R4SAS нет смысла

weko R4SAS: почему

R4SAS это не сделает погоды

orignal так чем 4096 плохо?

weko Почему не сделает? На шинде заработает

R4SAS weko: оно и сейчас работает

weko Ну тогда вообще похую нет?

R4SAS просто говорю что под виндами будет не 64*64, а 38*38

weko Так я же сказал как сделать чтобы 64 было

weko Просто префикс добавить для не поддерживаемых символов

weko Заменить их

R4SAS не

R4SAS надо по другому

weko orignal: крыл говорит FS везде не оптимальная

R4SAS смотре чего получается

R4SAS если у нас будет итератор создающий файлы, то создав pPP.db он не создаст pPp.db

R4SAS потому что винда думает что такой файл уже есть

weko Ну я ж говорю добавить к буквам префикс типо f = f, F = *f

R4SAS звездочку точно нельзя, при чем ни где )))

weko Ну тогда другое что-то

weko Сохранить таблицу замены и норм

weko Главное чтобы фс хотя бы 64 символа поддерживала и сойдёт....

weko А можно и меньше даже

weko Наверное))

weko Но извращаться не имеет смысла:)

R4SAS надо как то написать интерфейс для работы с файлом...

weko Да... Вообще можно как то начиная с конкретного байта читать?

weko И можно ли сказать ОС, чтобы как можно меньше файл фрагментировался? Чтобы быстрее чтение работало

R4SAS fseek

weko Хорошо тогда

weko Можно и 32 символа использовать, тогда имя в два раза больше будет

R4SAS это не нужно

weko Ещё нужен какой-то алгоритм "кучи" для файла с данными

R4SAS знаешь чего

R4SAS у нас длина по идее фиксированная

weko Ну да

R4SAS но я всё равно думаю что надо делать какой то маркер в конце записи

weko Ну можно CRC туда писать например

weko 4 байта

R4SAS да можно и без него

R4SAS но как потом удалять записи посередине?

weko Удалить с хэштаблицы

R4SAS и

weko И всё

R4SAS а с файла с данными?

weko А зачем оттуда

weko Мы же теперь знаем что там место свободное

weko Так как в таблице нету

R4SAS тогда надо как то это обозначать

weko Велосипелностью так и прёт :)

R4SAS знаю)))

R4SAS мы вообще сейчас сидим разрабатываем sqlite )))

weko R4SAS: ну в таблице нету записи про этот кусок, значит туда можно что-то записать

weko R4SAS: ага

weko Ну до sqlite далеко ещё, но по сути да)))

R4SAS ну как далеко

R4SAS внести поля, разметку, типы полей и готово

weko Наверное))

R4SAS а как ты себе хеш таблицу представляешь?

R4SAS какой вид?

weko R4SAS: ну хэш таблица это массив

R4SAS как оно будет в файле выглядеть?

weko Ну там будет место начала (4 байта), место конца(4 байта)

weko И всё

weko Как массив будет

R4SAS нам не нужно место конца

weko R4SAS: нужно чтобы знать куда пихнуть можно

weko Хотя хз

weko Тут сложно))

weko Как массив в памяти лежит, так и будет в файле

weko Друг за дружком

R4SAS ну будет у тебя 6 записей удалено

R4SAS между двумя

R4SAS можно это не изменит сути, всё равно тебе надо будет найти место, и записать ту же длину данных

R4SAS которая вполне легко вычисляема

weko Бошка болит

R4SAS и все равно придется итерировать по всем записям таблицы

weko Так может просто откуда-то код спиздить?

R4SAS откуда? вот именно

R4SAS думаешь я не искал?))

weko R4SAS: придётся... Сектора вроде для того и придумали, чтобы сократить время итерирования

weko R4SAS: а хз откуда))э

weko Из sqlite?)

R4SAS ой, так тот еще пиздец

R4SAS там*

weko Хотя оттуда пиздить - быстрее самим написать

weko Не знаю, мне кажется "DB" в "NetDB" оправдывает DB-зависимость. Ну либо велосипед делать:)

R4SAS еще это знаешь на что смахивает?

R4SAS на berkley db

weko Может в boost есть что-то?

R4SAS не встречал

R4SAS из аналогов вроде есть leveldb

weko Berkly db - oracle - стало не комфортно. Но код спиздить можно.

weko Да слышал

weko От гугла вроде

R4SAS м...

R4SAS github.com/stevedekorte/skipdb/tree/master/libs/skipdb/source

weko 15 лет

weko Хех

R4SAS аналогичное: github.com/feeblefakie/luxio

R4SAS ))

R4SAS unqlite.org/intro.html

R4SAS github.com/symisc/unqlite

R4SAS пиздец, 1.86 мб исходник

weko i2pd 5mb вроде

orignal нунах

R4SAS по идее нам действительно нужна key->value бд

R4SAS в ключе соответственно будет RI

R4SAS в value последовательность байт из данных

weko Ну дак

weko Но желательно ещё структуру чтобы профили было нормально хранить

R4SAS из всех PEER_PROFILE_* записей

R4SAS структура будет простой

weko Ну например чтобы можно было новое поле в профили добавить

R4SAS везде будет int

R4SAS ну... это уже другой вопрос

R4SAS потому я как раз и говорил что нужен маркер конца записи

R4SAS и это уже не CRC будет

weko Ну в велосипедном варианте можно просто файлы разных версий делать

R4SAS да это то понятно

R4SAS но тут другой вопрос

R4SAS почему я по твоему полез смотреть b-tree аналоги?

weko А хз

weko Чтобы удобно было добавлять поля?

R4SAS потому что там есть менеджер базы

R4SAS именно

weko gnu.org.ua/software/gdbm/gdbm.html

R4SAS это уже как библиотека, т.е. зависимость

R4SAS которая не факт что будет везде

R4SAS особенно на ведре

R4SAS в openwrt есть: github.com/openwrt/packages/tree/master/libs/gdbm

R4SAS но всё равно не подходит из-за необходимости линковаться

weko В termux есть тоже

weko Значит под ведро собирается

R4SAS а насчет того как быть если объем не совпадает

R4SAS или если поле добавилось, а в имеющейся записи будет меньше данных

R4SAS значит надо хранить еще и метки записей

R4SAS точнее метки внутри записей

weko Популярная зависимость - archlinux.org/packages/core/x86_64/gdbm

weko man-db, zsh

polistern Я смотрю вы тут redis придумываете))

weko Велосипед головного мозга

R4SAS polistern: можно и так сказать, но нам нужно совсем на минималках

R4SAS чтобы можно было именно встроить

R4SAS а не обязываться чем то внешним

R4SAS weko: я так вижу у него есть одна неприятная зависимость

R4SAS libintl

weko Это в каком дистре

R4SAS а это значит что всё что собирается, статично, жирнеет в раза 2 сразу же

R4SAS weko: ldd /usr/lib/libgdbm...... попробуй

R4SAS я на вскидку написал путь, вероятно библиотека не там лежит

weko У меня нет такой зависимости

R4SAS в msys2 по крайней мере почему то она есть

weko ld-linux-x86-64.so.2

weko libc.so.6

weko linux-vdso.so.1

R4SAS сейчас попробую разди интереса прилинковать

R4SAS ради*

polistern А в boost ничего не подвезли?

R4SAS polistern: смотря в какой

weko Да надо бы посмотреть

polistern Ну просто если всё-таки добавлять зависимость, то из того, что и так в проекте есть. Особенно если уже там есть готовое.

R4SAS понятное дело

R4SAS потому и хотим без зависимостей

orignal никаких дополнительных зависимстей

R4SAS я всё же смотрю в сторону интеграции LuxIO

R4SAS или самим реализовывать b+-tree

R4SAS github.com/shimianto/b-tree

orignal самим конечно

orignal ничего сложного

R4SAS github.com/Kronuz/cpp-btree

R4SAS github.com/tzlaine/Boost-Btree

R4SAS github.com/Beman/btree/tree/master

R4SAS > B-tree library for eventual proposal to Boost

R4SAS т.е. народ пытался протолкнуть b-tree в буст

orignal да не надо его там

orignal сделай тупой идекс

orignal а записи не удаляются а только помечеются

R4SAS а в момент save что делать?

orignal страые оставлять новые добавлять в конец

orignal иногда делать реидиндекс

R4SAS считывать весь файл и пропуская помеченные записи записывать с добавлением новых?

R4SAS а зачем оставлять?

orignal чтобы индекс не ехал

orignal если удалишь из середины придется весь индекс пересчитывать

R4SAS понятное дело

R4SAS но его можно при запии обновленного файла пересчитывать

orignal а когда делаем реидендекс тогда и чистим

orignal медленно будет

R4SAS почему?

orignal хотя наверное можно

R4SAS в индекс файле храним b32, startpos, length ?

orignal 32 байтный хэш и 4 байта позиция начала

orignal длину с самими данными

orignal чтобы можно было прочитать и без индекса

R4SAS хорошо, в данных тогда чего храним?

orignal то же что сейчас

orignal просто ini

R4SAS а смысл?

orignal чтобы можно было визумально посмотернть

R4SAS ты хочешь оставить его читаемым вручную?

R4SAS м... ясно

orignal обязательно

orignal не сериализацию же говродить

R4SAS не знаю как ты собираешься длину вычислять для такого типа

R4SAS и как её писать тем более

R4SAS ты не можешь перед блоком [b32] написать length=123

R4SAS и я не представляю как ты будешь получать местоположение начала данных при генерации ptree

R4SAS в общем массиве данных

orignal ты формат chunked видел?

orignal вот также

orignal снчала просто число с длиной

orignal со след строки сами данные

R4SAS я не понимаю как ты будешь позиции заполнять для ptree выхлопа

orignal мне не надо ptree

R4SAS ты сам говоршь ini

orignal угу

R4SAS что угу?

orignal я прочитаю в буфер и все

orignal надо профиль я беру из индекса начало

orignal там длину

R4SAS прочитаешь весь файл?

orignal зачем

orignal fseek для чего тебе дан

R4SAS хорошо, ну открыл ты файл

R4SAS нашел позицию начала

R4SAS дальше как найдешь позицию длины? отсчитаешь pos+35&

R4SAS ?

R4SAS как определишь сколько считать длиной?

R4SAS вдруг там будет число 12341 вместо привычных 123?

orignal так позиция начала это указатель как раз не длину

orignal как в chunked

orignal первая строка это длина

R4SAS у тебя еще есть секция, не забывай

orignal нет мне не надо секцию

orignal длина просто в файле как есть

R4SAS тогда это не init

R4SAS ini*

R4SAS ini

orignal а уже далешьше просто ini файл

orignal почему?

R4SAS эм

orignal <длина><ini файл>

orignal прочитали длину

orignal прочитали ini файл нужной длины в буфер

R4SAS еще раз, чего и где хранится

orignal парсим

R4SAS и в каком виде

R4SAS peerprofile.index хранит b32, pos

R4SAS peerprofile.db хранит... что? и в каком виде

R4SAS ты хочешь .db в ini формате

R4SAS но я не могу понять где у тебя длина

R4SAS и зачем эта длина в этом файле нужна?

weko [19:17:38] <orignal> чтобы можно было визумально посмотернть

weko [19:17:46] <orignal> обязательно

weko Да лучше уж читалку сделать

R4SAS почему нельзя это хранить в index&

orignal я хочу положить все .ini файлы в один большой

R4SAS ну

orignal и читать только нужные по индексу

orignal а не весь файл целиком

R4SAS тьфу. ты хочешь именно файлы толкать

R4SAS я думал что ты хочешь один файл сделать

R4SAS ini формата

orignal нет

weko И как расширять такое?

orignal много отдельных ini в одном большом

orignal расширять?

weko Ну новое поле например

weko Версии делать?

orignal зачем?

orignal переиндексировать и все

weko Ну затем что сейчас профилирование на уровне shit

orignal или если новая записть то старую поменетить как удаленную а новую в конец

weko При обновлении будет долго обновлять все записи а так ок

orignal R4SAS а че с сокс прокси?

R4SAS я то ожидал что будет один большой именно ini файл

orignal не пробоевал чинить что трусишка просил?

R4SAS paste.i2pd.xyz/?e4e8fc2642e3293e#5prZj4AcJKxT68XfC3Mu22wQgDXn6BnBGyX8Xa5276KM

orignal а вот не надо один большей

orignal лишний оверхед

R4SAS нет, вообще разговора не было

orignal огромное дерево в памяти

R4SAS нененене

weko Но вообще я хотел предложить сделать блоки, блок содержит какие то данные. В каждом блоке указатель на следующий блок. Последний блок с указателем 0. При обновлении когда нужно указатель в последнем блоке заменяем на новый блок

R4SAS мы не будем грузить его полностью

orignal ты не будешь грузить буст будет

R4SAS мы будем к этому файлу так же по fseek на обределенную длину байт обращаться

orignal weko изобрел FAT ))

weko orignal: да:)

R4SAS а потом уже эти прочтенные байты будут грузиться в ptree

R4SAS не весь файл

weko INI - в данном случае гемморой

weko Хотя смотря как сделать

weko Кстати в индексе RI не нужен

weko Потому что он есть в данных

weko Тоесть RouterIdent есть в RouterInfo

weko Тем более в индексе всё равно поиск по RI

R4SAS нужен

weko Кстати, что там по стратегии загрузки/выгрузки в память?

weko R4SAS: зачем

R4SAS чтобы не ползать по базе при поиске нужного RI

weko Так там хэш таблица

weko Куда там ползать

R4SAS что ты называешь RI ?

weko [19:39:20] <weko> Тоесть RouterIdent есть в RouterInfo

weko И RouterIdent в индексе не нужен

R4SAS и как без b32 RouterIdent ты будешь искать нужный тебе PeerProfile в бд?

R4SAS если у тебя не будет списка имеющихся записей

weko Ну вычисляю хэш. Хэш будет является индексом в массиве

weko Читаю по этому индексу адрес данных

R4SAS какой хеш?

weko Потом читаю данные по адресу и длине которая там первые 4 байта занимает

R4SAS что есть хеш?

R4SAS хеш чего?

weko Хэш RouterIdent

R4SAS чем хеш отличается от 32 байт RI?

weko Мы же по нему ищем всегда

weko R4SAS: тем что будет короче

weko Мы не хотим массив с 2^32 элементами?

weko Мы же*

weko А не

R4SAS почему 2^32?

weko 2^256

R4SAS чет я не понимаю вас

R4SAS либо вы меня

R4SAS либо всё взаимно

weko Потому что длина массива должна быть больше или равна максимального числа, которое выдаёт хэш функция

weko Так хэш таблица работает

weko Если мы возьмём сразу RouterIdent, нам придётся делать массив длинной 2^256

weko Потому что максимальное число RouterIdent - 2^256

weko Поэтому будет хэш-функция которая перегонит его в значее по короче

weko Надо будет коллизии как то решать

R4SAS <~orignal> 32 байтный хэш и 4 байта позиция начала

R4SAS при чем здесь массив?

R4SAS я не догоняю

weko Потому что хэш таблица хранит данные в массиве

R4SAS почему не std::map?

weko Ну можно его

weko Хотя лучше хэштаблицу

R4SAS std::map<RouterIdent, int64_t>

weko std::unordered_map

weko Ну да вернл

weko Тут главное взять байтовое представление и вписать в файл

R4SAS uint64_t **

weko В деревьях O(log n), а нам тут порядок не нужен

weko Так что std::unordered_map

R4SAS да это ясно

R4SAS я понял для чего ты начал про таблицу говорить

R4SAS чтобы быстро искать

R4SAS искать позицию

weko Ну да, мы же не хотим O(n) искать

weko Когда в памяти не оказалось

weko До этого всё делала FS

weko А сейчас нужно самим)

R4SAS с которой придется опять же обращаться в открытый файл и обращаться по позиции и считывать 4 байта чтобы выяснить длину записи

R4SAS это ладно

R4SAS НО!

weko Не знаю, это не я предлагал

R4SAS я вот этого не понимаю

R4SAS так я не говорю про тебя

R4SAS он же говорит файл файлов

weko Я смысла не вижу, все равно будет нечитаемая херня

R4SAS тогда я не понимаю смысла в этом всём

R4SAS почему тогда нельзя сделать tar файл?

weko Смысл хранить всё в одном файле и не грузить всё сразу

R4SAS habr.com/ru/articles/320834

weko Ну можно

weko Это уже дополнительный момент

R4SAS один файл? - да

weko Можно вообще индекс в том же файле хранить, просто в начале файла первые 4 байта будут указывать на то место, где лежит индекс

R4SAS в нем ini файлы? - да

R4SAS индекс есть? - да

R4SAS указатели есть? - да

weko Если нужно хранить много мелких файлов и при этом не сжимать файл, то tar — плохой выбор.

weko Статья выше))

R4SAS я видал

weko Проблема с блоками в том, что это по сути FS over FS

R4SAS но мы там можем кучу кода опустить

R4SAS нам не нужен чистый tar

weko Интересно, можно ли попросить ОС как можно меньше дефрагментировать файл?

weko Blinded message

weko Может просто сделаем блоки с запасом? 4кб?

orignal у меня же есть i2pdzip

orignal не знал?))

weko Нет))

orignal дед долго угорал

orignal посмотри в Reseed.cpp

weko Лол)

orignal там читается именно .zip afqk

orignal файд

weko А да чото видел такое

weko я думал это общий формат))

weko Второй

weko Как bob и sam

orignal ну .su3 в реальности это zip

orignal а его надо чем то читать чтобы записи извелкать

orignal и у меня это делается прямо в коде

weko Хах

R4SAS orignal: давай еще раз

R4SAS вид db

R4SAS как оно должно выглядеть

R4SAS как ты собираешься узнавать где какой пирпрофиль?

R4SAS каким образом это будут файлы, если это не архив

R4SAS я сейчас говорю о чтении без участия index файла

weko Интересно, а как выгрузить в std::unoredered_map массив в сыром виде? Там надо чтоб ещё хэш функция такая же осталась. Не оптимальный фикс - да, хранить RouterIdent. Но фактически это излишне

R4SAS вот это я очень сильно хочу понять

orignal говорю же ищем индекс а в нем смещение от начала

R4SAS так у тебя там будет такой вид на весь файл:

R4SAS 123

R4SAS lastseen=asdasdasa

R4SAS [asdasda]

R4SAS asdasdas=12312312

R4SAS это всё

orignal да именно так

orignal и че?

R4SAS это одна запись

weko Как длину читать будешь?

orignal stoi

orignal как с chunked счас делается

R4SAS <~orignal> много отдельных ini в одном большом

R4SAS <~orignal> чтобы можно было визумально посмотернть

weko Просто учитывайте как вы будете добавлять новые поля. Делать версии файлов - вариант стрёмный.

R4SAS <~orignal> чтобы можно было прочитать и без индекса

weko Router Info то ладно. А вот профили другой вопрос.

R4SAS смысл в чтении без индекса если в бд не хранится RouterIdent?

R4SAS я это не понимаю

R4SAS weko: это уже будет на совести ptree

weko ptree это что?

R4SAS в который по замыслу передается прочитанный блок

R4SAS boost property tree

R4SAS конкретно вот тут: github.com/PurpleI2P/i2pd/blob/openssl/libi2pd/Profiling.cpp#L93

R4SAS только мы будем туда передавать считаный кусок

R4SAS вместо пути

weko Так он умеет фрагментировать?

weko Иль как

R4SAS всм фрагментировать?

weko Ну как ты добавлять параметр будешь?

R4SAS добавится он и всё

weko Там же уже следцющие данные идут

R4SAS при чтении если какого то параметра нет или он пустой, то он опускается

R4SAS либо берется значение по умолчанию

weko Так а новый как добавить?

weko Сохранить новый не дефолтный как?

R4SAS github.com/PurpleI2P/i2pd/blob/openssl/libi2pd/Profiling.cpp#L51-L60

weko Ну это а один файл

weko Точнее это каждый в отдельный ыпйл

weko Файл

weko А когда файл один, сразу за этим INI идёт другой

weko И просто вставить не выйдет

weko Там уже занято

R4SAS так вставка в конец всегда

weko В конец чего?

R4SAS ты имеешь в виду обновление записи?

weko Обновление i2pd

R4SAS если в запись надо будет дописать новое что то?

weko Новое поле добавилось, его хранить надо

R4SAS ну, добавилось поле

weko Куда?

R4SAS в кожд

weko А в файл как?

R4SAS мы считываем старый RI

R4SAS в нем не будет поля

R4SAS по этому значение будет по дефолту

weko А что там будет?

R4SAS в структуре в рабочей памяти

weko Так а если оно стало не дефолтным?

R4SAS до момента записи на диск обновлений оно в памяти будет

weko И мы хотим его записать на диск

weko А когда запись на диск?

R4SAS это измененное состояние

weko Что тогда

R4SAS запись на диск по расписанию

weko Кажется примерно понял...

weko Но этот нужно отдельно оптимизировать

weko Чтобы не перезаписать то, что не нужно...

R4SAS будут перечитываться все записи, отмеченные на удаление будут пропускаться при записи, обновленные - игнорироваться данные на диске именющиеся, на их место запишутся новые (с новым полем), а не измененные останутся в исходном

weko Перезаписывать*

R4SAS виде.

R4SAS и файл будет полностью перезаписываться

weko Полностью мерезаписывать нужно когда новое поле добавилось на самом деле

weko В остальных случаях это излишне

R4SAS ты на каждый чих собираешься перезаписывать?

R4SAS а вот нифига

weko Как раз таки нет

R4SAS посмотри в пирпрофили

weko Ну 6 часов понятно

weko Но всё равно излишне

weko Тем более лучше сделать меньше

weko И таким образом можно будет сделать меньше

R4SAS у тебя значения могут быть 1 символ, а могут быть 2 и даже 3 символа

R4SAS lastunreachabletime может добавляться и удаляться при доступности роутера

weko Так выделим 8 байт

weko С запасом хватит

R4SAS на что?

weko На значения

R4SAS у тебя не бинарный файл по пожеланию лося

weko Ну тогда никакой оптимизации

R4SAS у тебя он в том виде, какой он сейчас есть

R4SAS это уже огномная оптимизация

weko Хотя проще читалку сделать чем делать намеренно костыль

R4SAS что не дергается каждый пирпрофиль

weko Ну уже да

weko Но можно лучше

R4SAS я знаю

R4SAS я это изначально и хотел сделать

R4SAS но видишь, ему хочется читаемый вид

weko Вопрос только в хранении RouterIdent в индексе

R4SAS так уже решили ведь что это 32 байта

weko Чтобы не хранить, нужен способ получить std::unordered_map с той же хэш функциией

R4SAS по которым ты заполняешь таблицу дальше при запуске ш2зв

weko Да просто думаю как экономить

weko [20:29:02] <weko> Чтобы не хранить, нужен способ получить std::unordered_map с той же хэш функциией

weko **из голого массива

R4SAS сейчас бд обрела такой вид:

R4SAS paste.i2pd.xyz/?dc9dbfd79d52397a#DiKFvvAx6z7Qyoko1Zm5duTXkhmvXuEoJvdZnYcPErV7

R4SAS при запуске читаем pp.index, в нем 32+4 в итераторе

R4SAS заполняем хеш таблицу по RI (32), значения ставим из offset (4)

weko Все ещё не пойму как длину читать

R4SAS при необходимости прочесть RI ABC мы по H (хеш таблице) ищем ABC

weko [20:33:02] <R4SAS> заполняем хеш таблицу по RI (32), значения ставим из offset (4)

weko Понимаешь, вопрос в том, хранить ли RI в таблице самой? Если нет [20:29:02] <weko> Чтобы не хранить, нужен способ получить std::unordered_map с голого массива с той же хэш функциией

R4SAS находим оффсет

weko Хм, длину можно до \n читать...

R4SAS именно

R4SAS fseek на offset

R4SAS читаем до \n

weko Ну это да

R4SAS вычисляем длину прочтенного числа

weko Длина кстати включая длинну записи длинны или нет?

R4SAS нет, без него

weko Окей

weko И без \n тогда надо

weko А последний \n включаем

weko Верно?

R4SAS потом берем и читаем offset + len_len + 1, len

R4SAS и полученные данные вливаем в ptree::load

R4SAS последний \n наверно при любом раскладе попадет туда

R4SAS в это число

R4SAS надо переделать lastupdatetime на unixtime

R4SAS нафиг этот текстовый вариант записи

weko ++

weko Языко-зависимый ещё

weko Ну вот почему нету способа получить unordered_map из массива напрямую?

weko Очередные костыли...

R4SAS я не понимаю зачем

weko Чтобы RouterIdent не хранить

weko Потому что он не нужен в индексе

R4SAS почему не нужен то?

R4SAS а к чему ты привязывать собираешься?

R4SAS записи то

weko Запись в файл - просто запись массива. Поиск - по RouterIdent мы и ищем (мы его знаем). Чтение - имея и массив и хэш функцию, можно получить годную для поиска хэш таблицу

weko Ну ладно

weko Не буду на это время тратить

weko Пусть будет как будет

R4SAS я опять не понимаю зачем тебе хеш функция?

R4SAS ты собираешься хранить хеш RouterIdent?

R4SAS зачем?

weko Нет

weko Не хранить вовсе

R4SAS почему нельзя сделать DHT таблицу и заполнить её байтами RI?

R4SAS и искать по ней

R4SAS да, это будет 256 бит, ну а куда деваться

R4SAS но, как я говорил, я наверно тоже туплю, и не понимаю чего ты хочешь получить

R4SAS меня больше беспокоит как читать и записывать

R4SAS на данный момент по крайней мере

weko R4SAS: потому что в dht поиск O(log n)

R4SAS так тут аналогично будет, не?