Why is my Memory dumping soo slow?

Question

The idea behind this program is to simply access the ram and download the data from it to a txt file. Later Ill convert the txt file to jpeg and hopefully it will be readable . However when I try and read from the RAM using NEW[] it takes waaaaaay to long to actually copy all the values into the file? Isnt it suppose to be really fast? I mean I save pictures everyday and it doesn't even take a second? Is there some other method I can use to dump memory to a file?

#include <stdio.h>
#include <stdlib.h>
#include <hw/pci.h>
#include <hw/inout.h>
#include <sys/mman.h>


main()
{
    FILE *fp;
    fp = fopen ("test.txt","w+d");
    int NumberOfPciCards = 3;
    struct pci_dev_info info[NumberOfPciCards];
    void *PciDeviceHandler1,*PciDeviceHandler2,*PciDeviceHandler3;
    uint32_t *Buffer;
    int *BusNumb;   //int Buffer;
    uint32_t counter =0;
    int i;
    int r;
    int y;
    volatile uint32_t *NEW,*NEW2;
    uintptr_t iobase;
    volatile uint32_t *regbase;

    NEW = (uint32_t *)malloc(sizeof(uint32_t));
    NEW2 = (uint32_t *)malloc(sizeof(uint32_t));
    Buffer = (uint32_t *)malloc(sizeof(uint32_t));
    BusNumb = (int*)malloc(sizeof(int));
    printf ("\n 1");

    for (r=0;r<NumberOfPciCards;r++)
    {
        memset(&info[r], 0, sizeof(info[r]));
    }

    printf ("\n 2");

        //Here the attach takes place.
    for (r=0;r<NumberOfPciCards;r++)
    {
        (pci_attach(r) < 0) ? FuncPrint(1,r) : FuncPrint(0,r);
    }

    printf ("\n 3");

    info[0].VendorId = 0x8086;  //Wont be using this one
    info[0].DeviceId = 0x3582;   //Or this one
    info[1].VendorId = 0x10B5;   //WIll only be using this one PLX 9054 chip
    info[1].DeviceId = 0x9054;   //Also PLX 9054
    info[2].VendorId = 0x8086;   //Not used
    info[2].DeviceId = 0x24cb;    //Not used

    printf ("\n 4");

        //I attached the device and give it a handler and set some setting.
    if ((PciDeviceHandler1 = pci_attach_device(0,PCI_SHARE|PCI_INIT_ALL, 0, &info[1])) == 0)
                {
                    perror("pci_attach_device fail");
                    exit(EXIT_FAILURE);
                }

            for (i = 0; i < 6; i++)
            //This just prints out some details of the card.    
                                {
                if (info[1].BaseAddressSize[i] > 0)
                    printf("Aperture %d: "
                    "Base 0x%llx Length %d bytes Type %s\n", i,
                    PCI_IS_MEM(info[1].CpuBaseAddress[i]) ? PCI_MEM_ADDR(info[1].CpuBaseAddress[i]) :   PCI_IO_ADDR(info[1].CpuBaseAddress[i]),
                            info[1].BaseAddressSize[i],PCI_IS_MEM(info[1].CpuBaseAddress[i]) ? "MEM" : "IO");
                }
            printf("\nEnd of Device random info dump---\n");


    printf("\nNEWs Address : %d\n",*(int*)NEW);
        //Not sure if this is a legitimate way of memory allocation but I cant see to read the ram any other way.
    NEW = mmap_device_memory(NULL, info[1].BaseAddressSize[3],PROT_READ|PROT_WRITE|PROT_NOCACHE, 0,info[1].CpuBaseAddress[3]);

                 //Here is where things are starting to get messy and REALLY long to just run through all the ram and dump it.
                 //Is there some other way I can dump the data in the ram into a file?
        while (counter!=info[1].BaseAddressSize[3])
        {

            fprintf(fp, "%x",NEW[counter]);
            counter++;
        }

        fclose(fp);

    printf("0x%x",*Buffer);

}

Answer 1

A few issues that I can see:

• You are writing blocks of 4 bytes - that's quite inefficient. The stream buffering in the C library may help with that to a degree, but using larger blocks would still be more efficient.

• Even worse, you are writing out the memory dump in hexadecimal notation, rather than the bytes themselves. That conversion is very CPU-intensive, not to mention that the size of the output is essentially doubled. You would be better off writing raw binary data using e.g. fwrite().

• Depending on the specifics of your system (is this on QNX?), reading from I/O-mapped memory may be slower than reading directly from physical memory, especially if your PCI device has to act as a relay. What exactly is it that you are doing?

In any case I would suggest using a profiler to actually find out where your program is spending most of its time. Even a rudimentary system monitor would allow you to determine if your program is CPU-bound or I/O-bound.

As it is, "waaaaaay to long" is hardly a valid measurement. How much data is being copied? How long does it take? Where is the output file located?

P.S.: I also have some concerns w.r.t. what you are trying to do, but that is slightly off-topic for this question...

Answer 2

For fastest speed: write the data in binary form and use the open() / write() / close() API-s. Since your data is already available in a contiguous block of (virtual) memory it is a waste to copy it to a temporary buffer (used by the fwrite(), fprintf(), etc. API-s).

The code using write() will be similar to:

int fd = open("filename.bin", O_RDWR|O_CREAT, S_IRWXU);
write(fd, (void*)NEW, 4*info[1].BaseAddressSize[3]);
close(fd);

You will need to add error handling and make sure that the buffer size is specified correctly.

To reiterate, you get the speed-up from:

• avoiding the conversion from binary to ASCII (as pointed out by others above)
• avoiding many calls to libc
• reducing the number of system-calls (from inside libc)
• eliminating the overhead of copying data to a temporary buffer inside the fwrite()/fprintf() and related functions (buffering would be useful if your data arrived in small chunks, including the case of converting to ASCII in 4 byte units)

I intentionally ignore commenting on other parts of your code as it is apparently not intended to be production quality yet and your question is focused on how to speed up writing data to a file.