Always write to top of file
-
Its too slow when I open -> write -> close a file (see code below). Are they a way of opening the file and always writing at the top of the file; e.g. I do not want to Append text, just write the same 100 lines of text each time at the top of the file.
#include <stdio.h>
FILE * pFile;
/* open file and check if was successful */
if ((pFile = fopen("myfile.txt", "w")) == NULL)
{
/* couldn't open file; do some error handling if u want */
}
else
{
/* do s.th. */
/* close file */
fclose(pFile);
}Waiting in hope!
grahamfff
-
Its too slow when I open -> write -> close a file (see code below). Are they a way of opening the file and always writing at the top of the file; e.g. I do not want to Append text, just write the same 100 lines of text each time at the top of the file.
#include <stdio.h>
FILE * pFile;
/* open file and check if was successful */
if ((pFile = fopen("myfile.txt", "w")) == NULL)
{
/* couldn't open file; do some error handling if u want */
}
else
{
/* do s.th. */
/* close file */
fclose(pFile);
}Waiting in hope!
grahamfff
-
Its too slow when I open -> write -> close a file (see code below). Are they a way of opening the file and always writing at the top of the file; e.g. I do not want to Append text, just write the same 100 lines of text each time at the top of the file.
#include <stdio.h>
FILE * pFile;
/* open file and check if was successful */
if ((pFile = fopen("myfile.txt", "w")) == NULL)
{
/* couldn't open file; do some error handling if u want */
}
else
{
/* do s.th. */
/* close file */
fclose(pFile);
}Waiting in hope!
grahamfff
// I do not want to Append text, just write the same 100 lines of text each time at the top of the file. Any appending in the file context is more rapid than an inserting. Of course, you could try to append the reversed content to be read later as reversed as well... :)
They sought it with thimbles, they sought it with care; They pursued it with forks and hope; They threatened its life with a railway-share; They charmed it with smiles and soap. :)
-
No, there is no way, since all the data that you write would overwrite whatever is already there. You would need to hold the data in memory, and rewrite all of it every time.
Veni, vidi, abiit domum
I just want to append to the TOP of the file each time. Its too slow doing an open -> write -> close. In a 20 msec loop and sometimes two files need to hav data written to them. No timing problems with the append, but this could result in large files if I do not overwirie.
grahamfff
-
I just want to append to the TOP of the file each time. Its too slow doing an open -> write -> close. In a 20 msec loop and sometimes two files need to hav data written to them. No timing problems with the append, but this could result in large files if I do not overwirie.
grahamfff
-
Grahamfff wrote:
I just want to append to the TOP of the file each time.
As I said before, you cannot do it; the system just does not work that way. Perhaps it would be better if you explained why you want to do this.
Veni, vidi, abiit domum
-
In a 20 msec loop and sometimes two files need to have data written to them and the open -> write -> close takes about 8-10 msec each and sometimes get an overrun.
grahamfff
-
In a 20 msec loop and sometimes two files need to have data written to them and the open -> write -> close takes about 8-10 msec each and sometimes get an overrun.
grahamfff
As Eugen alludes to, a time-critical loop is not the place to muck about. Write the data to the end of the file then deal with the order later on. Furthermore, I assume that you're dealing with different files each time through the loop. If not, then again, don't muck about. Open the file before the loop and close it again afterwards.
-
Its too slow when I open -> write -> close a file (see code below). Are they a way of opening the file and always writing at the top of the file; e.g. I do not want to Append text, just write the same 100 lines of text each time at the top of the file.
#include <stdio.h>
FILE * pFile;
/* open file and check if was successful */
if ((pFile = fopen("myfile.txt", "w")) == NULL)
{
/* couldn't open file; do some error handling if u want */
}
else
{
/* do s.th. */
/* close file */
fclose(pFile);
}Waiting in hope!
grahamfff
Grahamfff wrote:
Are they a way of opening the file and always writing at the top of the file;
Do you mean having the newest data at the beginning of the file (rather than at the end)?
"One man's wage rise is another man's price increase." - Harold Wilson
"Fireproof doesn't mean the fire will never come. It means when the fire comes that you will be able to withstand it." - Michael Simmons
"Show me a community that obeys the Ten Commandments and I'll show you a less crowded prison system." - Anonymous
-
Grahamfff wrote:
Are they a way of opening the file and always writing at the top of the file;
Do you mean having the newest data at the beginning of the file (rather than at the end)?
"One man's wage rise is another man's price increase." - Harold Wilson
"Fireproof doesn't mean the fire will never come. It means when the fire comes that you will be able to withstand it." - Michael Simmons
"Show me a community that obeys the Ten Commandments and I'll show you a less crowded prison system." - Anonymous
-
Its too slow when I open -> write -> close a file (see code below). Are they a way of opening the file and always writing at the top of the file; e.g. I do not want to Append text, just write the same 100 lines of text each time at the top of the file.
#include <stdio.h>
FILE * pFile;
/* open file and check if was successful */
if ((pFile = fopen("myfile.txt", "w")) == NULL)
{
/* couldn't open file; do some error handling if u want */
}
else
{
/* do s.th. */
/* close file */
fclose(pFile);
}Waiting in hope!
grahamfff
Open the file as "read/update": fopen ("myfile.txt", "r+"), link: http://www.cplusplus.com/reference/cstdio/fopen/[^] The use fseek (SEEK_SET) to position the file pointer to the beginning of the file. Link: http://www.cplusplus.com/reference/cstdio/fseek/[^] You can then just overwrite 100 lines of text, without having to write the WHOLE file.
-
Yes that would do! They are recoverery data files, so periodically writing them. Just interested in the newest data.
grahamfff
Grahamfff wrote:
They are recoverery data files,
Now, finally, you are providing some useful info. First off, the file system is a bottleneck. The only way to speed up file access is use a different file system. But you probably don't have that choice. Second, repeatedly writing to hard disk in a fixed time loop every 20ms is an incredibly stupid idea, for various reasons - this is simply not the intended purpose of a file system! You should consider different storage media, depending an what is available to you, or you should consider to just wait longer between writes. I'm not an expert on this, but Flash drives, SRAM, or even USB may be more suitable. (Although writing to flash drives 50 times per second is a sure way to destroy them in short order...) Third, I can't think of any reason to write recovery info more often then once every couple of seconds: a recovery feature usually means the ability to restore a state that is difficult to reproduce, either because it is the result of interacting with a non-deterministic system (such as a human), or because there is no other way to reproduce the data (e. g. in very long range communication such as talking to mars rovers and the like). Either way, losing the data from as little a timespan as one second is meaningless! OTOH, if for whatever incomprehensible reason you really, really need that info stored every 0.02s flawlessly, then the file system simply is too slow to reliably do this - not to mention that trying it will slow your entire application to a crawl. As suggested above, use a different storage medium!
GOTOs are a bit like wire coat hangers: they tend to breed in the darkness, such that where there once were few, eventually there are many, and the program's architecture collapses beneath them. (Fran Poretto)