Hoi,

mijn aanvraag (eigenlijk bibliotheek) indexen een bestand van vele GB produceren tabellen (arrays van offset en lengte van de gegevens geïndexeerd) voor later hergebruik. De tabellen zijn ook behoorlijk groot, zo groot dat ik liep uit het geheugen in mijn proces (3GB limiet), bij het indexeren van meer dan 8GB dossier of zo. Hoewel ik kon vork een ander proces om te werken rond het geheugen limiet grootte, zou dit niet het probleem op te lossen, dus ik wil graag dump de tabellen naar een bestand om gratis het geheugen, en vermijd om opnieuw indexeren hetzelfde bestand meer dan een keer.

Houd er rekening mee dat moment, de tabellen zijn bewaard in het geheugen in een gekoppelde lijst, gedeeld met een andere thread die gebruiken voor de productie van een andere lijst van gefilterde gegevens. Dus ik liever niet veranderen dit schema. De andere draad alleen toegang tot de lijst een keer het hele bestand is geïndexeerd.

Nu, de vragen die ik mezelf de vraag zijn:

- Wanneer en hoe is het beste tijd te dumpen de tabellen naar een bestand?

Dumpingcode een tabel als deze krijgt volledige klinkt niet erg efficiënt voor mij. Zou ik blijf er niets in het geheugen? De gelinkte lijst zou altijd leeg? Als ik besluit om N tabellen in het geheugen, en dump elke N, hoe kan ik voorkomen dat het maken van een check voor hoeveel tafels heb ik
in het geheugen bij elke cyclus?

- Wie moet dumpen de metadata geproduceerd tot het dossier? Verschillende draad? Dezelfde thread die index de gegevens? Ik ben het ook niet zou willen produceren metadata bestanden wanneer het bestand verwerkt is minder dan een giga (klein bestand geval is), maar tegelijkertijd zou ik niet willen complexer de code van de indexeerfunctie, dat nu is vrij eenvoudig: parse, vindt de gegevens, maakt u een item tabel toevoegen. Als de tabel vol is, maak een andere en voeg deze toe aan de gelinkte lijst.

- Laten we zeggen dat ik dacht dat (met dank aan u) de beste manier (in mijn geval) te dumpen de metadata. Wat moet ik gebruiken voor het laden van de gegevens in om te laten de andere draad
filteren van de index van gegevens zonder radicaal veranderen van de manier waarop het werkt nu (bijvoorbeeld door middel van de gelinkte lijst)?

Een oplossing die in mijn ogen, die zou voorkomen dat een drastical verandering in mijn schema is het creëren van een "list manager" dat zou een interface toe te voegen en op te halen element uit de lijst. Deze entiteit (een draad of een proces) zou zorgen dat bepaalde gegevens in het geheugen (gekoppeld lijst) en enkele andere in het bestand.

Gelieve met mij deelt uw vaardigheden en ervaring! :-)

Thanks in advance.

Groeten,
S.

Wow, wat een vraag. Bent u re-engineering van een database systeem?
Op iets minder dan gigabyte grenzen. Eigenlijk, 256 kB blokken werken ook erg goed.
Als het in een andere draad, wat is het punt? U kunt niet alleen gratis het geheugen als de andere thread nog een lock op.
Ik denk niet dat de verantwoording, tenzij een echt weet uw bestaande software-architectuur.

Nope. Ik probeer te schrijven een aanvraag zo efficiënt als mogelijk is, dat moet dumpen indexen tafel, en ik zou graag willen leren zo veel mogelijk van deze ervaring.

Bedoel je voor de uitvoering van een fwrite van een 256KB buffer? Momenteel heb ik een lijst waar elk element (tabel) is een array van N, voor een totale omvang van 4Kb per array, en ik dump elke tafel in een keer met een enkele fwrite.

Eigenlijk een draad (A) indexeert het bestand, terwijl een andere thread (B) wacht tot het klaar is, om gebruik te maken van de geproduceerde tabellen (die ik gebruikt om in het geheugen) om de gegevens te verwerken in het bestand. Het probleem is dat het bestand geïndexeerd zijn enorm (~ 30GB) en de productie van meer dan 4 GB aan gegevens, die ik niet kan blijven in het geheugen (limiet van 3 GB per proces) ja, op een punt of een ander heb ik te dumpen de geproduceerde gegevens in een bestand om gratis het geheugen.

De andere draad (B), gebaseerd op een vlag, of lees de tabellen uit het bestand of de lijst in het geheugen.

Bedankt voor uw hulp,
S.

Ik kan het niet helpen, andere dan citeer een oude software ontwerp stelregel:

Je bedoelt dat ik moet gebruik maken van een database voor het houden van de tabellen, net als sqlite?

Welke database voornamelijk afhankelijk van hoe u veel indexeerbare en unieke kolommen je hebt, op de verhouding tussen de lezers voor schrijvers. sqlite? LOL. Ik dacht meer langs de lijnen van MySQL of BerkelyDB / SleepyCat DB.

Dat is waarom ik niet zou willen gebruiken een database. De werkzaamheden, en de afhankelijkheid geproduceerd, is het niet waard in mijn geval (IMHO).

Ik heb alleen een schrijver en een lezer.

De gegevens zijn geschreven achtereenvolgens, en nooit gewijzigd. Write Once, Read Many.

Een ad-hoc oplossing dacht ik zou mijn beste manier om te gaan.

Ik waardeer uw gedachten over dit.

Bedankt,
S.