CVI debugger reports dynamic memory corrupt

Hi,
There is a problem most likely between debugger and CVIXML group of functions.
When I operate even one of CVI examples involving population of tree control out of XML the following function corrupting heap:
                CVIXMLGetElementValue (data,result);
It is important to recognize that even NI example "XMLTree" do not work correctly under debugger (breakpoints and single step).
However if release mode is selected then apparently no problems are noticeable.
Obviously I selected different debugger modes. But no cure found.
///// failing example
        char * result;      
        CVIXMLElement data = 0;
        assert(!CVIXMLGetChildElementByTag (column, "Data", &data));
        if (data) {
            int len;
            char * bs;
            CVIXMLGetElementValueLength (data, &len);
            if(len) {
                result=malloc(len+1);
                bs=malloc(1);
                free(bs);
                CVIXMLGetElementValue (data,result);
                bs=malloc(1);
                free(bs);                                 ///////////////// problem right here
                RemoveSurroundingWhiteSpace(result);
                bs=malloc(1);
                free(bs);
      printf("row=%i, column=%i >>>%s<<<\n",j,i,result);   
      free(result);      
        } else (result=""; //empty string (but printable ;-)
      CVIXMLDiscardElement(data);
/// But if variables are coming from stack then no problem occured.
        char result[100];      
        CVIXMLElement data = 0;
        assert(!CVIXMLGetChildElementByTag (column, "Data", &data));
        if (data) {
            int len;
            char * bs;
            CVIXMLGetElementValueLength (data, &len);
            if(len) {
                bs=malloc(1);
                free(bs);
                CVIXMLGetElementValue (data,result);
                bs=malloc(1);
                free(bs);
                RemoveSurroundingWhiteSpace(result);
                bs=malloc(1);
                free(bs);
        } else result[0]=0; //empty string (but printable ;-)
      printf("row=%i, column=%i >>>%s<<<\n",j,i,result);   
      CVIXMLDiscardElement(data);
Is there any remedy now other than giving up on debugger???
I am using brand new CVI 8.0.1 version and cannot use static data holders..
Otta

Mikie,
You should never attempt to write past the end of an array when programming in C. In fact you should be getting a fatal run-time error when you attempt to write past the end of an array. This is a feature of CVI that blocks the user from performing such actions which ANSI C does not prevent. What does your code look like that does this? Here is the code I have and as you can see in the comments, I receive the error before I get to freeing the memory.
#include <ansi_c.h>
int main (int argc, char *argv[])
int *myArray;
myArray = malloc(2*sizeof(int));
*(myArray) = 1;
*(myArray+1) = 2;
*(myArray+2) = 3; //FATAL RUN_TIME ERROR: Dereference of out-of-bounds pointer
free (myArray);
return 0;
National Instruments
Product Support Engineer

Similar Messages

  • Why doesn't the debugger follow dynamic memory allocations well?

    Here's an example of a code block that doesn't seem to work right with the CVI compiler/debugger, but works fine with other C compilers/debuggers
    struct arg_int* arg_intn(const char* shortopts,
    const char* longopts,
    const char *datatype,
    int mincount,
    int maxcount,
    const char *glossary)
    size_t nbytes;
    struct arg_int *result;
    /* foolproof things by ensuring maxcount is not less than mincount */
    maxcount = (maxcount<mincount) ? mincount : maxcount;
    nbytes = sizeof(struct arg_int) /* storage for struct arg_int */
    + maxcount * sizeof(int); /* storage for ival[maxcount] array */
    result = (struct arg_int*)malloc(nbytes);
    if (result)
    /* init the arg_hdr struct */
    result->hdr.flag = ARG_HASVALUE;
    result->hdr.shortopts = shortopts;
    result->hdr.longopts = longopts;
    result->hdr.datatype = datatype ? datatype : "<int>";
    result->hdr.glossary = glossary;
    result->hdr.mincount = mincount;
    result->hdr.maxcount = maxcount;
    result->hdr.parent = result;
    result->hdr.resetfn = (arg_resetfn*)resetfn;
    result->hdr.scanfn = (arg_scanfn*)scanfn;
    result->hdr.checkfn = (arg_checkfn*)checkfn;
    result->hdr.errorfn = (arg_errorfn*)errorfn;
    /* store the ival[maxcount] array immediately after the arg_int struct */
    result->ival = (int*)(result+1);
    result->count = 0;
    /*printf("arg_intn() returns %p\n",result);*/
    return result;
    When I try to dereference this structure's 'ival[0]' the debugger constantly complains of a fatal runtime error and declares it out of the array bounds.
    This is from the argtable2 open source library available at http://argtable.sourceforge.net/ if you want to try and reproduce it.  I'm using CVI 2010 SP1.

    Unfortunately, you have run into one of the inherent limitations of CVI's run-time checking. Even though it is perfectly legal in C and somewhat common practice, our run-time checking doesn't like it when you conceptually split up a block of memory and treat it as two or more separate blocks. 
    While I cannot fix the problem in our run-time checking without breaking other use cases, I can explain what's causing the error and how you can work around it.
    When you malloc memory, we assume that the memory block is going to hold one or more instances of the type to which you're casting the memory block. In this case, CVI is treating the new memory block as an array of arg_info structures. But your new memory block is not big enough to hold more than one instance of struct arg_info, so we implicitly truncate the memory block to sizeof(struct arg_info). Because of the implicit truncation, s->values is now pointing past the end of the memory block and any access will result in an error.
    #include <ansi_c.h>
    struct arg_int {
    char some_large_block[64];
    int count;
    int *values;
    int main (int argc, char *argv[])
    int i, n = 4;
    struct arg_int *s = malloc(sizeof *s + n * sizeof *s->values);
    s->count = n;
    s->values = (int *)(s+1);
    for (i = 0; i < n; ++i)
    s->values[i] = i;
    return 0;
    You can avoid the implicit truncation in the original code by assigning to a (void*) first. This retains the original block size by keeping the actual type of the data in the memory block in limbo. Subsequent casts do not truncate the block. We truncate only when the cast occurs implicitly as part of a malloc. s->values points to the remainder of the block and you can access it freely, but you do not get any run-time checking on it.
    #include <ansi_c.h>
    struct arg_int {
    char some_large_block[64];
    int count;
    int *values;
    int main (int argc, char *argv[])
    int i, n = 4;
    struct arg_int *s;
    void *memory = malloc(sizeof *s + n * sizeof *s->values);
    s = memory;
    s->count = n;
    s->values = (int *)(s+1);
    for (i = 0; i < n; ++i)
    s->values[i] = i;
    return 0;
    If you want full run-time checking on s->values, you have to allocate the two components separately.
    #include <ansi_c.h>
    struct arg_int {
    char some_large_block[64];
    int count;
    int *values;
    int main (int argc, char *argv[])
    int i, n = 4;
    struct arg_int *s = malloc(sizeof *s);
    s->count = n;
    s->values = malloc(n * sizeof *s->values);
    for (i = 0; i < n; ++i)
    s->values[i] = i;
    return 0;
    Another option is to use an incomplete array. An incomplete array is an array of unspecified or zero size at the end of a structure definition. CVI is implicitly growing the array to fill up the rest of the allocated memory block. You do not get run-time checking for the array.
    #include <ansi_c.h>
    struct arg_int {
    char some_large_block[64];
    int count;
    int values[0];
    int main (int argc, char *argv[])
    int i, n = 4;
    struct arg_int *s = malloc(sizeof *s + n * sizeof *s->values);
    s->count = n;
    for (i = 0; i < n; ++i)
    s->values[i] = i;
    return 0;
    You can also disable run-time checking for your memory block by going through a series of casts: http://zone.ni.com/reference/en-XX/help/370051K-01/cvi/disablinguserprotectionforindividualpointer/
    Best regards.

  • Dynamic memory is corrupt (Labwindows/cvi 2010)

    I have a multi threaded application....where I have a buffers allocated ineternally in the threads,,...A user interface is present to abort the therad execution.
    Here is the code in one of the threads (NOTE: status is set by a user button to EXIT the program):
    int EthernetDataStructureThread (void *functionData)
        CmtSetCurrentThreadPriority (2);
        EthernetData GetData={0}, *data=NULL;
        data = &GetData;
        /* Use a buffer to read the data from the queue which is coming from TCP read with fresh data */
        const void *BufferEth;
        int BytesRead=0;
        int BytesWritten=0;
        char ReadErrorMessage[256];
        BOOL bitset = FALSE;
        if ( (BufferEth = (EthernetData*)malloc(EthernetDataSize)) != NULL)
            while ( !status )
                BytesRead = CmtReadTSQData (Queue_TCPRead_EthernetData, BufferEth, EthernetDataSize, TSQ_INFINITE_TIMEOUT, 0);
                memcpy (data, BufferEth, EthernetDataSize);
                /* Empty the queue so that we don't have data in next time. */
                CmtFlushTSQ (Queue_TCPRead_EthernetData, TSQ_FLUSH_ALL, NULL);
                //Pass on the data to the Main thread
                BytesWritten = CmtWriteTSQData (Queue_EthernetData_Main, BufferEth , EthernetDataSize, 1, NULL);
                if ( BytesWritten != EthernetDataSize)
                     free(BufferEth);
                    BufferEth = NULL;
                    exit(0);
                Delay(0.02);
            if (status && !bitset)
                free(BufferEth);
                BufferEth = NULL;
                bitset = TRUE;
        return 0;
    My problem is: free(BuffEth) always says Dynamic Memory is corrupt......When I put a breakpoint and keep seeing the resource tracking window, I can see it getting executed fine as the resource tracking window greys out the memory block....but then suddenly free wants to exceute again...and causes the "dynamic memory is corrupt" error.
    I am using LABWINDOWS /CVI 2010 SP1 in WinXP.
    Please help me ASAP....very much appreciated.
    Regards
    NITIN
    -Nharish

    Thank you for your reply Jackie.
    I am calling Free only once...there is an If condition there.
    See the attched video for my problem...Free frees the memory block (see the greyed out portion in resource tracking window but still the statement controls remains there and free executes again, throwing error).
    Do you  think it is some sort of bug in LABWINDOWS.
    See the attached video.
    -Nharish
    Attachments:
    FreeproblemLabwindows.avi ‏4781 KB

  • Solving corrupt dynamic memory problem

    Using LabWindows/CVI 2010, Windows XP. I have a data acquisition program that uses a rather large number of dynamically allocated arrays as buffers. The buffers are used to hold data from DAQmx and are passed and copied to a number of thread-safe queues and other routines. In certain circumstances, when I free one buffer I get a "dynamic memory is corrupt" error, which probably means - from reading the other posts on this topic on this forum - that some buffer was written past its end and corrupted the dynamic memory linked list. Is there any good way to determine exactly <i>which</i> buffer was corrupted? I don't believe that it was the one that I get the error on, it was probably the previous or next one in the chain. I can see the memory chain in the resource window, but I'm not sure how to interpret it.

    Hi pblase, 
    Here is an KnowledgeBase article that was written for LabWindows\CVI 6.0 but it still has some valid suggestions for debugging in LabWindows\CVI 2010:
    http://digital.ni.com/public.nsf/allkb/862567530005F09C8625632500692F41?OpenDocument
    There are three valid suggestions to debug from this article.  The only one that does not work still is the Run » Dynamic Memory feature.
    Peter T
    Applications Engineer
    National Instruments

  • I get "dynamic memory is corrupt" when I call HarmonicAnalyzer function

    Hello,
    I am using a PCI-6025E to acquire analog signals. I want to measure the THD of some of them, so I have copied the function "Total_Harmonic_Distortion" from the THD_Analyzer.prj example of NI.
    Sometimes, my program crash when it tries to execute the HarmonicAnalyzer function.
    My program is multi-threading, the acquisition and the THD measurement is made in the same thread.
    Someone can help me to fix this problem?
    Thanks

    Dear SebastianN,
    thanks for your suggestion. I have tried to call the "CVIDynamicMemoryInfo" before the HarmonicAnalyzer function, but it has no effect on the program itself (I get always the memory corrupt message).
    Yesterday I tried to call the Total_Harmonic_Distortion only if the RMS value of my buffer is greater than 1.0, and I replaced all my malloc functions by calloc functions. Till now it seems to work, but I cannot understand why, and I'm not sure that really I fixed the problem...

  • IPhone SDK 2.2 memory corruption

    Hello. I'm working on an application for iPhone SDK 2.2 and seem to be having weird memory corruption problems. Not necessarily leaks because using Instruments shows my memory stamp never going above about 1.8 megs. The nature of the app is a database of animals so I'm constantly loading and unloading sounds and images. None of the objects are very large (at most I'll have 4 800k pngs loaded at once) and I've checked and rechecked my alloc/retain/release and everything is in order (hence no memory usage increase). However...after using the application for a while I'll notice strange behavior. For example:
    1) we have a UILabel as the title for each page. After a while the font size of this will change.
    2) I have several screens with a subclassed UIScrollView where images are loaded and then added to. The problem shows itself here by the images not showing up. there's no crash, stepping through the debugger shows that the image loads up fine, it's just that the image is not there.
    3) I have a UILabel at the top of an animal description screen, which in the nib file is called "Animal Name" by default. This will change to show "Animal Name" at the top.
    I've removed all audio in our latest build so that isn't the problem. What I'm starting to suspect is that altering anything defined in a nib file will cause corruption. For example, the UIScrollView is defined in the nib file, and I constantly am reassigning the contents of that with a UIImageView. This UIImageView is handled within the subview class like :
    UIImageView *imgView = [[UIImageView alloc] initWithImage: [ UIImage imageWithContentsOfFile:[[NSBundle mainBundle ] pathForResource:imageToLoad ofType:@"png" ]] ];
    imgView.tag = 50;
    [self addSubview:imgView ];
    [ imgView release ];
    Then later when moving away from the screen I'll find that view's tag and remove it from the superview (since addSubView increases the retain count, the alloc+addSubView is cancelled by release+removeFromSuperView)
    I can't explain why titles that are never changed would be affected, but it must somehow be related. What I'm wondering is: are there any known issues involving modification of the contents of objects defined in Nib files? Perhaps the memory allocated when initWithNibName is restrained, then any modification of objects allocated within it can cause corruption. I'm starting to think I should just alloc and free anything modified in code and skip using nib files altogether (I reset the text on buttons for example). If this is a known issue please let me know. I'll give you more information if I can.
    Thank you

    Just download the huge SDK package and install. No need to uninstall the old SDK.

  • Memory Corrupts on Re-start of 5500

    I have a Nokia 5500 that came with firmware v3.14 and I upgraded last week to v3.55 using the Nokia Software Updater successfully. But since then I have been having a problem with my memory card. Everytime I switch off and on the phone and try to access the memory card, it says that the memory card is corrupted. After a format it works till the next re-start.
    I tried formatting the phone and also doing a full format using windows but even now whenever I restart the phone the memory card gets corrupted. I wonder if this is a problem with the new firmware.
    Has anyone faced such a problem and can anyone guide me on how to rectify this problem. Would it help if I somehow revert back to the older firmware? If yes, then how do I reinstall the older firmware version?
    Thanks in Advance,
    Prashanth

    Sad to say, I have a similar and recurrent problem with my E61. Out of nowhere, it will report "Memory Card Corrupted," and the only "solution" it offers is to Format the card. Brilliant. I've accepted that option twice now, and have also done reformats in my PC Card reader in both FAT and FAT32. No difference. The E61, when so inclined, reports the "Memory Card Corrupted" and I'm back to square one. A REAL annoyance as I have serious applications (e.g., TomTom Navigator on my card). Nokia has been quite unhelpful with my previous queries about SD cards. The essence of what they told me was that if it's not a NOKIA brand card, then they won't do anything. But, the bigger question is: what CAN they do? There's NO reason to think this is a card-specific issues. It's much more likely that it's a NOKIA phone defect. Having a Nokia-branded SD card would mean only that I had the dubious satisfaction of getting the same message with a "supported" card. Not exactly a motivation to buy an over-priced Nokia brand card.

  • Dynamic memory allocation failure

    Dear reader,
    We sometimes have a problem where our windows 2012 r2 RDS virtual servers, that reside on windows 2012r2 hyper-v hosts, loose their dynamic memory and only have their startup memory left to work with. Users start complaining that things are very slow etc.
    If I check several screens (RDS Broker load balancing, hyper-v manager, cluster manager and the vm's task manager) it's clear that the vm only has its startup memory allocated. I'm not sure if this happens instantly or immidiatly after the nightly reboot.
    To resolve the problem we have to call all users on the vm where it happens and ask them to logoff (if they are even able to), and then we reboot the machine.
    I have checked the logs from the machine where the VM resides on and the logs from the vm itself. But I cannot find anything. We also have alot of windows 2008r2 vm's with dynamivc memory, but none of those have ever had this problem.
    Searched the internet, but so far it seems we are only.
    Can anyone give me a lead to troubleshoot this?
    Best regards,
    Ruud Boersma
    MCITP Enterprise administrator

    Hi all,
    I'm going to be "one of those people" who revives dead posts for something that is relevant but obviously not fixed... sorry in advance!
    We have the exact same situation, a bunch of RDSH guests with Dynamic memory turned on (60+ of them). every day between 1-8 of them will fail to allocate Dynamic memory and will be stuck on their startup RAM amount. This really hurts our users at peak
    times.
    I have engaged our TAM and have raised a case with PSS, Usual story "your the only one with this problem". Which obviously isn't true.
    So, we have tons of free RAM on the hosts, 600GB+ on most of them, the issue affects RDSH hosts at random, across multiple hosts and clusters.
    The screen shots attached are of one of our hosts from this morning. it has 8GB startup, 8GB minimum, 32GB Maximum RAM configured, with a 23% buffer. the host has 752GB RAM FREE. Notice how the perf counter "Hyper-V Dynamic Memory Integration Service"
    is reporting "0", it should be reporting "32768". also under task manager on the VM we are missing "Maximum memory" which should be just below "Hardware reserved" in the bottom right hand corner.
    Looks like the balloon driver is being delayed at boot time, we are going to XPerf all the servers in the hope that we can catch the critter. It's an unusual problem.
    We only have Acrobat PDF viewer, word viewer, excel viewer and two custom dot.NET applications installed on the guests. Some of the servers are also just dumb RDSH hosts, with not connection broker configured, using an F5 loadbalancer for load distribution
    and session management. All guests are 2012R2 patched up to March 2015, integration Services are installed and up to date (its an enlightened OS remember).

  • Dynamic Memory is not working all the time

    We are in the process off moving our 2008R2 VM's from the 2008R2 HyperV servers to new Server 2012R2 Hosts.
    We shut down the VM's copy the files and VHD's to the new CSV's en import the VM in the Hyperv Manager. Then we make them high available in the Failover Cluster Manager (Configure role - Virtual machine). We mount the integration tools and update the
    VM to version 6.3.9600.16384
    For a specific type of VM (mostly RDS Host servers) we always had Dynamic Memory configured (when they were hosted on de 2008R2 platform), so we are using the same settings on the 2012r2 platform. The memory settings were;
    Startup memory: 1024 MB
    Minimum memory: 1024 MB
    Maximum memory: 12288 MB
    These VM's reboot every morning, this is done for specific reasons. But now once in a while (once per week/2 weeks) we notice that the VM's are not using more memory then 1024 MB while the demand is much higher. Rebooting the server helps most of the times,
    live migrating to another host also helps. In the VM we see that memory usage in the taskmanager is 99-100%, and after the move it immediately starts using more than the minimum configured amount.
    Until the failover the memory usage was 1024 MB and it did not get any higher.
    This happened several times. Last week we changed the Memory configuration to:
    Startup memory : 2048 MB
    Minimum memory: 2048 MB
    Maximum memory: 12288 MB
    But this morning we had a call about the performance of one of the VM's, We saw that it was only using 2 GB memory while the demand was much higher. After live migrating it to another host it started using more memory immediately.
    The 2012R2 hosts are not overcommited, there is a lot of memory still available for the VM's. Those VM's never had this problem on the 2008R2 Hyperv platform.
    Any idea why this happens?
    Peter Camps

    Peter,
    I think this is a bug of some sort. I say that because the components that make up dynamic memory are as follows.
    Memory Balancer(Host service, coordinates how memory changes are made.) This is also what shows the memory demand counter i believe.
    Dynamic Memory Virtualization Service Provider (this is included your VMWP.exe proccess, one per VM. Essentially how it runs on the host. He listens to the Service Client for metrics)
    Dynamic Memory Virtualization Service Client (this is inside the VM and reports to the Dynamic Memory Virtualizaton Service Provider.)
    Since you live migrated the machine it made dynamic memory work on the other host. This means the Service Client is running in the client and shouldn't be an issue. The Memory Balancer is the server and shouldn't be the issue, so this means the "Dynamic
    Memory Virtualization Service Provider" is in question. When you live migrate the machine its going to create a new VMWP.exe process on the clustered server. So now the question is it the host that couldn't listen to the service or the worker process
    skipped a beat and has a bug.
    Out of curiosity does it happen to both hosts? Also have you profiled the servers to see how much memory they really require on start-up? When you reboot the RDS servers, how many VM's do you reboot and is it a staggered process?

  • Dynamic memory not released to host

    Dear Techies,
    Ours is a small Hyper V virtual server infrastructure with three DELL power-edge physical hosts(Windows server 2012 Datacenter) and around 15 virtual machines running on top of it. The hosts are added to fail-over cluster. Each host has 95 GB RAM. All the
    VMs are running Windows server 2012 standard edition.
    We have installed terminal services(TS licensing, TS connection broker, TS session host) in four VMs with the following dynamic memory settings:
    Start-up RAM : 2048 MB
    Minimum RAM : 2048 MB
    Maximum RAM : 8192 MB
    Below mentioned applications are configured in the server:
    Nova Application Installed
    SQL Developer Tool is Configured (ODBC Connection established for Database communication)
    FTPs communication allowed for File Transfer
    McAfee Agent is configured (Virus Scanner)
    Nimsoft Robot Agent Configured – Monitoring
    Terminal Service
    Enabled Multiple terminal sessions based on customer requirement
    BGinfo tool configured through group policy for customized desktop background
    The average memory utilization in the terminal servers are 3.6 GB. As per dynamic allocation the maximum RAM requirement/allocation till date is 4GB. As seen in Hyper V console, the current RAM demand is 2300 MB and assigned memory is 2800 MB.
    However, the earlier assigned RAM in the server is ballooned/faked to the VM as driver locked memory. This is by design. Despite the memory being released back to the host, the server still shows up the 4Gb which makes the memory utilization report from
    monitoring tools look 80% (3.2 GB out of 4 GB).
    As a result, the memory utilization report is always based on the current dynamically allocated RAM and not calculated based on the maximum assigned RAM(8GB in this case). To make it clear: If the
    currently assigned RAM is 4Gb and utilization is 3.2 GB the utilization % is reported as 80%. However, if calculated in accordance with maximum RAM capacity of the server it would be 40% ((3.2/8)*100).
    Is there any way to release the driver locked memory from the VM.?
    Regards, 
    Auditya N

    I am not really clear on the point of your question.
    Allocated RAM is what is currently in use / allocated to a VM out of the physical RAM pool.  It is Demand + Buffer.  The demand is based on the applications in the VM and what they think they need and how efficiently they return unused memory
    to the machine.  This has nothing to do with in-application paging (which happens a lot with Terminal Servers).
    So yes, the memory utilization is accurate in relation to physical RAM utilization.
    Dynamic Memory is about efficiency, not about over-allocation.  Hyper-V can never give VMs more RAM than is in the physical RAM pool.  The VMs can be configured to have more RAM than is in the physical RAM pool - but the VMs will hit the top of
    the pool and not be allowed to have any more.  There is no ballooning or paging to disk.
    So, you maximum allocated could go beyond what is possible.  But that would mean that your utilization would be artificially low if this was used in the calculation.
    Brian Ehlert
    http://ITProctology.blogspot.com
    Learn. Apply. Repeat.

  • [2008 R2] Hyper-V Dynamic memory warning with half of vHost memory free

    Our virtual server host system has about 19GB of Memory free (out of 32GB total), yet a virtual guest using Dynamic Memory was only being assigned 8GB and the demand was around 13GB, therefore generating a Warning state on the Memory Status. Logging onto
    the guest machine showed about 8GB of memory being used as well. The end-users were receiving memory errors in their applications. Any idea why the guest system was in this warning state?

    There is a perception in the OS.  And different numbers come from different places.
    In a nutshell, the RDP Server has a memory leak if you constantly disconnect and reconnect - and it ends up chewing up memory, but when available memory is tested this memory consumption is missed. If you logout of the RDP session instead of disconnecting
    then the memory is given back and can actually be used.
    It is a strange interaction with RDP that has been there since the original release.  But it is specific to using RDP to connect to the Hyper-V Server for VM Management and disconnecting without ever logging out.
    There was also a google process that many folks reported a long while back that caused memory consumption that prevented VMs from starting as well.
    Brian Ehlert
    http://ITProctology.blogspot.com
    Learn. Apply. Repeat.
    Disclaimer: Attempting change is of your own free will.

  • Memory corruption due to bad RAM in late 2012 iMac

    I just unpacked a brand new late-2012 iMac a few days ago. Its specs are basically maxed out, only choice being the 3TB fusion drive. To summarize:
    3.4 GHz Core i7
    32GB RAM
    3TB Fusion Drive
    2GB NVidia
    Latest patches for Mountain Lion
    Since I got it, I have been experiencing intermittent abnormalities with it. Programs randomly crash with error messages along the lines of "such and such file appears corrupt, please run --repair".
    I do a lot of programming in my job and just today I started getting bizarre 'segmentation fault' messages in Terminal. What worked just a few minutes ago started crashing with a segfault. The exact same programs have no negative effect on my Macbook Pro and work just fine. In a matter of minutes, the entire iMac became unresponsive and I got the "we shut down your computer to prevent damage" panic screen.
    After a reboot, I started thinking it could be some sort of memory corruption. I downloaded the 'memtest' utility and started the basic test with:
    memtest all 2
    In just a few minutes, below are the results I receive (I re-ran multiple times to the same effect).
    Any opinions on whether this is indeed bad RAM? How do I handle this with Apple support? Any suggestions/comments are most welcome.
    Thank you,
    Ozgun
    Excerpt from the crash report in Console:
    Process:         ghc [96618]
    Path:            /usr/local/lib/ghc-7.6.2/ghc
    Identifier:      ghc
    Version:         ???
    Code Type:       X86-64 (Native)
    Parent Process:  Emacs-10.7 [37299]
    User ID:         501
    Date/Time:       2013-03-20 21:06:30.389 -0400
    OS Version:      Mac OS X 10.8.3 (12D78)
    Report Version:  10
    Crashed Thread:  0  Dispatch queue: com.apple.main-thread
    Exception Type:  EXC_BAD_ACCESS (SIGSEGV)
    Exception Codes: EXC_I386_GPFLT
    Thread 0 Crashed:: Dispatch queue: com.apple.main-thread
    0   ghc                                     0x000000010bb44b10 evacuate1 + 5296
    1   ghc                                     0x000000010bb4927f scavenge_block1 + 703
    2   ghc                                     0x000000010bb4a78c scavenge_loop1 + 1548
    3   ghc                                     0x000000010bb4639e scavenge_until_all_done + 798
    4   ghc                                     0x000000010bb46c57 GarbageCollect + 1639
    5   ghc                                     0x000000010bb378ff scheduleDoGC + 991
    6   ghc                                     0x000000010bb3982b schedule + 1579
    7   ghc                                     0x000000010bb39df4 scheduleWaitThread + 164
    8   ghc                                     0x000000010bb3478e real_main + 68
    Memtest Results:
    Memtest version 4.22 (64-bit)
    Copyright (C) 2004 Charles Cazabon
    Copyright (C) 2004-2008 Tony Scaminaci (Macintosh port)
    Licensed under the GNU General Public License version 2 only
    Mac OS X 10.8.3 (12D78) running in multiuser mode
    Memory Page Size: 4096
    System has 8 Intel core(s) with SSE
    Requested memory: 24009MB (25176211456 bytes)
    Available memory: 24009MB (25176211456 bytes)
    Allocated memory: 24009MB (25176211456 bytes) at local address 0x0000000101000000
    Attempting memory lock... locked successfully
    Partitioning memory into 2 comparison buffers...
    Buffer A: 12004MB (12588105728 bytes) starts at local address 0x0000000101000000
    Buffer B: 12004MB (12588105728 bytes) starts at local address 0x00000003ef4f4000
    Running 2 test sequences... (CTRL-C to quit)
    Test sequence 1 of 2:
    Running tests on full 24009MB region...
      Stuck Address       : testing  1 of 16
    FAILURE! Data mismatch at local address 0x0000000262d778c0
    Actual Data: 0x0200000262d778c0
      Linear PRN          : testing  1 of 16
    FAILURE! Data mismatch at local address 0x0000000262d77900
    Expected Data: 0xa378ecfaa3ecf6b9, Actual Data: 0x0178ecfaa3ecf6b9
    Running comparison tests using 12004MB buffers...
      Random Value        :
    FAILURE! Data mismatch at local BUFA address 0x0000000262d778c0, BUFB address 0x000000055126b8c0
    BUFA Data: 0x3ddd57d041eb5a06, BUFB Data: 0x3fdd57d041eb5a06
      Compare XOR         :
    FAILURE! Data mismatch at local BUFA address 0x0000000262d778c0, BUFB address 0x000000055126b8c0
    BUFA Data: 0x826aabfcebf44332, BUFB Data: 0x806aabfcebf44332
      Compare SUB         :
    FAILURE! Data mismatch at local BUFA address 0x0000000262d778c0, BUFB address 0x000000055126b8c0
    BUFA Data: 0x8e6cbb4010b8a88d, BUFB Data: 0x8a6cbb4010b8a88d
      Compare MUL         :
    FAILURE! Data mismatch at local BUFA address 0x0000000262d778c0, BUFB address 0x000000055126b8c0
    BUFA Data: 0x54fd2f0176d1ab9e, BUFB Data: 0xfefd2f0176d1ab9e
      Compare DIV         :
    FAILURE! Data mismatch at local BUFA address 0x0000000262d778c0, BUFB address 0x000000055126b8c0
    BUFA Data: 0x0200000000000000, BUFB Data: 0x0000000000000002
      Compare OR          :
    FAILURE! Data mismatch at local BUFA address 0x0000000262d778c0, BUFB address 0x000000055126b8c0
    BUFA Data: 0x6eaf35c4f7fc13fb, BUFB Data: 0x6caf35c4f7fc13fb
      Compare AND         :
    FAILURE! Data mismatch at local BUFA address 0x0000000262d778c0, BUFB address 0x000000055126b8c0
    BUFA Data: 0x6ea704c077fc1399, BUFB Data: 0x6ca704c077fc1399
      Sequential Increment:
    FAILURE! Data mismatch at local BUFA address 0x0000000262d778c0, BUFB address 0x000000055126b8c0
    BUFA Data: 0x7caad7e9fb32b8ca, BUFB Data: 0x7eaad7e9fb32b8ca
      Solid Bits          : testing  1 of 64
    FAILURE! Data mismatch at local BUFA address 0x0000000262d778c0, BUFB address 0x000000055126b8c0
    BUFA Data: 0xfdffffffffffffff, BUFB Data: 0xffffffffffffffff
      Block Sequential    : testing   1 of 256
    FAILURE! Data mismatch at local BUFA address 0x0000000262d778c0, BUFB address 0x000000055126b8c0
    BUFA Data: 0x0200000000000000, BUFB Data: 0x0000000000000000
      Checkerboard        : testing  1 of 64
    FAILURE! Data mismatch at local BUFA address 0x0000000262d77900, BUFB address 0x000000055126b900
    BUFA Data: 0x0155555555555555, BUFB Data: 0x5555555555555555
      Bit Spread          : testing   1 of 128
    FAILURE! Data mismatch at local BUFA address 0x0000000262d778c0, BUFB address 0x000000055126b8c0
    BUFA Data: 0x0200000000000005, BUFB Data: 0x0000000000000005
      Bit Flip            : testing   1 of 512
    FAILURE! Data mismatch at local BUFA address 0x0000000262d778c0, BUFB address 0x000000055126b8c0
    BUFA Data: 0xfdfffffffffffffe, BUFB Data: 0xfffffffffffffffe
      Walking Ones        : testing   1 of 128
    FAILURE! Data mismatch at local BUFA address 0x0000000262d77900, BUFB address 0x000000055126b900
    BUFA Data: 0x11fffffffffffffe, BUFB Data: 0xfffffffffffffffe
      Walking Zeroes      : testing   1 of 128
    FAILURE! Data mismatch at local BUFA address 0x0000000262d778c0, BUFB address 0x000000055126b8c0
    BUFA Data: 0x0200000000000001, BUFB Data: 0x0000000000000001
    Test sequence 2 of 2:
    Running tests on full 24009MB region...
      Stuck Address       : testing  1 of 16
    FAILURE! Data mismatch at local address 0x0000000262d778c0
    Actual Data: 0x0200000262d778c0
      Linear PRN          : testing  1 of 16
    FAILURE! Data mismatch at local address 0x0000000262d77900
    Expected Data: 0xa378ecfaa3ecf6b9, Actual Data: 0x0178ecfaa3ecf6b9
    Running comparison tests using 12004MB buffers...
      Random Value        :
    FAILURE! Data mismatch at local BUFA address 0x0000000262d778c0, BUFB address 0x000000055126b8c0
    BUFA Data: 0xf54d78773a1d75d1, BUFB Data: 0xf74d78773a1d75d1
      Compare XOR         :
    FAILURE! Data mismatch at local BUFA address 0x0000000262d77900, BUFB address 0x000000055126b900
    BUFA Data: 0x01e08f19e0bd343d, BUFB Data: 0xbbe08f19e0bd343d
      Compare SUB         :
    FAILURE! Data mismatch at local BUFA address 0x0000000262d77900, BUFB address 0x000000055126b900
    BUFA Data: 0x01e38c4ae6cbd9e0, BUFB Data: 0x5be38c4ae6cbd9e0
      Compare MUL         :
    FAILURE! Data mismatch at local BUFA address 0x0000000262d77900, BUFB address 0x000000055126b900
    BUFA Data: 0x01d2ccf452aabcc0, BUFB Data: 0x5ed2ccf452aabcc0
      Compare DIV         :
    FAILURE! Data mismatch at local BUFA address 0x0000000262d778c0, BUFB address 0x000000055126b8c0
    BUFA Data: 0x0200000000000003, BUFB Data: 0x0000000000000003
      Compare OR          :
    FAILURE! Data mismatch at local BUFA address 0x0000000262d77900, BUFB address 0x000000055126b900
    BUFA Data: 0x01f97d3f343b8641, BUFB Data: 0xe7f97d3f343b8641
      Compare AND         :
    FAILURE! Data mismatch at local BUFA address 0x0000000262d77900, BUFB address 0x000000055126b900
    BUFA Data: 0x0181413c143a0641, BUFB Data: 0xe381413c143a0641
      Sequential Increment:
    FAILURE! Data mismatch at local BUFA address 0x0000000262d77900, BUFB address 0x000000055126b900
    BUFA Data: 0x11df0c80ebf82821, BUFB Data: 0xf2df0c80ebf82821
      Solid Bits          : testing  1 of 64
    FAILURE! Data mismatch at local BUFA address 0x0000000262d77900, BUFB address 0x000000055126b900
    BUFA Data: 0x11ffffffffffffff, BUFB Data: 0xffffffffffffffff
      Block Sequential    : testing   1 of 256
    FAILURE! Data mismatch at local BUFA address 0x0000000262d778c0, BUFB address 0x000000055126b8c0
    BUFA Data: 0x0200000000000000, BUFB Data: 0x0000000000000000
      Checkerboard        : testing  1 of 64
    FAILURE! Data mismatch at local BUFA address 0x0000000262d77900, BUFB address 0x000000055126b900
    BUFA Data: 0x0155555555555555, BUFB Data: 0x5555555555555555
      Bit Spread          : testing   1 of 128
    FAILURE! Data mismatch at local BUFA address 0x0000000262d778c0, BUFB address 0x000000055126b8c0
    BUFA Data: 0x0200000000000005, BUFB Data: 0x0000000000000005
      Bit Flip            : testing   1 of 512
    FAILURE! Data mismatch at local BUFA address 0x0000000262d778c0, BUFB address 0x000000055126b8c0
    BUFA Data: 0xfdfffffffffffffe, BUFB Data: 0xfffffffffffffffe
      Walking Ones        : testing   1 of 128
    FAILURE! Data mismatch at local BUFA address 0x0000000262d77900, BUFB address 0x000000055126b900
    BUFA Data: 0x11fffffffffffffe, BUFB Data: 0xfffffffffffffffe
      Walking Zeroes      : testing   1 of 128
    FAILURE! Data mismatch at local BUFA address 0x0000000262d778c0, BUFB address 0x000000055126b8c0
    BUFA Data: 0x0200000000000001, BUFB Data: 0x0000000000000001
    *** Address Test Failed ***  One or more DIMM address lines are non-functional.
    Execution time: 230 seconds.
    ➜  ~  memtest all 2

    This must be my last last thing.  AHT was on an iMac I bought in 2009.  It was included on my "disk 2" along with several other applications.  When I wiped and installed the full Lion, AHT was gone.  Same is true for the full Mountain Lion installation media.  It does not have AHT.  I'm not at all sure how to get it back from Apple.
    I was able to find it on my SL disc 2 and extract it again from that.  Disc 2 won't install on Mountain Lion (the packages are too out of date) but the AHT pkg does.
    Since you have it, consider packing it up and keeping it safe.  Maybe someone who knows AHT better than I can elaborate on AHT.  From what I've seen, you get it when your mac ships but if you ever wipe and reinstall the OS, you lose it.

  • Memory Corruption?

    Hi there, recently I reinstalled Windows and upgraded from 7 to 8.1. Back on Windows 7 I had a strange bsod every so often when playing this one game I like called Dungeon Defenders: Eternity. Part of the reason I switched from 7 to 8.1 was to get a fresh
    install of Windows and some driver compatibility so I could play it bug free. It worked for about 4 days too! On Win 7 the bsod was 'probably caused by nwifi.sys' but if you look down at the new Windows 8.1 dump it says that it's a 'memory_corruption'. How
    should I go about fixing this? I have some unused RAM from ages ago, never opened so I guess I could replace it, but it would be a downgrade. I guess what I'm trying to figure out is... Do I need new RAM? Is it faulty?
    Oh ya, before I forget, due to this bsod only being caused by ONE game and my pc running perfectly everywhere else, I can't help but feel like my RAM is not the issue here.
    Somebody save me!
    Microsoft (R) Windows Debugger Version 6.3.9600.17237 AMD64
    Copyright (c) Microsoft Corporation. All rights reserved.
    Loading Dump File [C:\Windows\Minidump\082614-16890-01.dmp]
    Mini Kernel Dump File: Only registers and stack trace are available
    ************* Symbol Path validation summary **************
    Response                         Time (ms)     Location
    Deferred                                       srv*D:\Symbols*http://msdl.microsoft.com/download/symbols
    Symbol search path is: srv*D:\Symbols*http://msdl.microsoft.com/download/symbols
    Executable search path is: 
    Windows 8 Kernel Version 9600 MP (8 procs) Free x64
    Product: WinNt, suite: TerminalServer SingleUserTS
    Built by: 9600.17085.amd64fre.winblue_gdr.140330-1035
    Machine Name:
    Kernel base = 0xfffff800`a0283000 PsLoadedModuleList = 0xfffff800`a054d2d0
    Debug session time: Mon Aug 25 22:10:40.540 2014 (UTC - 6:00)
    System Uptime: 0 days 2:58:59.267
    Loading Kernel Symbols
    Loading User Symbols
    Loading unloaded module list
    *                        Bugcheck Analysis                                    *
    Use !analyze -v to get detailed debugging information.
    BugCheck A, {fffff6fb40069d88, 0, 0, fffff800a02f858b}
    Probably caused by : memory_corruption ( nt!MiAgeWorkingSet+2cb )
    Followup: MachineOwner
    5: kd> !analyze -v
    *                        Bugcheck Analysis                                    *
    IRQL_NOT_LESS_OR_EQUAL (a)
    An attempt was made to access a pageable (or completely invalid) address at an
    interrupt request level (IRQL) that is too high.  This is usually
    caused by drivers using improper addresses.
    If a kernel debugger is available get the stack backtrace.
    Arguments:
    Arg1: fffff6fb40069d88, memory referenced
    Arg2: 0000000000000000, IRQL
    Arg3: 0000000000000000, bitfield :
    bit 0 : value 0 = read operation, 1 = write operation
    bit 3 : value 0 = not an execute operation, 1 = execute operation (only on chips which support this level of status)
    Arg4: fffff800a02f858b, address which referenced memory
    Debugging Details:
    READ_ADDRESS: GetPointerFromAddress: unable to read from fffff800a05d7138
    unable to get nt!MmNonPagedPoolStart
    unable to get nt!MmSizeOfNonPagedPoolInBytes
     fffff6fb40069d88 
    CURRENT_IRQL:  0
    FAULTING_IP: 
    nt!MiAgeWorkingSet+2cb
    fffff800`a02f858b 498b1e          mov     rbx,qword ptr [r14]
    CUSTOMER_CRASH_COUNT:  1
    DEFAULT_BUCKET_ID:  WIN8_DRIVER_FAULT
    BUGCHECK_STR:  AV
    PROCESS_NAME:  DUNDEFGAME.EXE
    ANALYSIS_VERSION: 6.3.9600.17237 (debuggers(dbg).140716-0327) amd64fre
    TRAP_FRAME:  ffffd000c7cb76d0 -- (.trap 0xffffd000c7cb76d0)
    NOTE: The trap frame does not contain all registers.
    Some register values may be zeroed or incorrect.
    rax=0000800000000000 rbx=0000000000000000 rcx=0000ffffffffffff
    rdx=0000000000000008 rsi=0000000000000000 rdi=0000000000000000
    rip=fffff800a02f858b rsp=ffffd000c7cb7860 rbp=ffffd000c7cb7960
     r8=0000000fffffffff  r9=8000000000000000 r10=0000007ffffffff8
    r11=0000098000000000 r12=0000000000000000 r13=0000000000000000
    r14=0000000000000000 r15=0000000000000000
    iopl=0         nv up ei ng nz na po cy
    nt!MiAgeWorkingSet+0x2cb:
    fffff800`a02f858b 498b1e          mov     rbx,qword ptr [r14] ds:00000000`00000000=????????????????
    Resetting default scope
    LAST_CONTROL_TRANSFER:  from fffff800a03e2ae9 to fffff800a03d6fa0
    STACK_TEXT:  
    ffffd000`c7cb7588 fffff800`a03e2ae9 : 00000000`0000000a fffff6fb`40069d88 00000000`00000000 00000000`00000000 : nt!KeBugCheckEx
    ffffd000`c7cb7590 fffff800`a03e133a : 00000000`00000000 ffff0000`00000000 00000000`00001000 ffffd000`c7cb76d0 : nt!KiBugCheckDispatch+0x69
    ffffd000`c7cb76d0 fffff800`a02f858b : 00000000`00017608 00000000`0000012b 00000003`00000000 00000000`73576d4d : nt!KiPageFault+0x23a
    ffffd000`c7cb7860 fffff800`a030bfa5 : ffffe000`bb4c6ad8 00000000`00000002 00000000`00000002 00000000`ffffffff : nt!MiAgeWorkingSet+0x2cb
    ffffd000`c7cb7b70 fffff800`a030bbba : 00000000`00000000 ffffd000`c7cb7c39 ffffe000`bb4c6af0 00000000`00000000 : nt!MiTrimOrAgeWorkingSet+0xc1
    ffffd000`c7cb7bb0 fffff800`a0346b92 : 00000000`00000000 ffffe000`b655f880 00000000`00000001 ffffe000`b655f880 : nt!MiProcessWorkingSets+0x1a6
    ffffd000`c7cb7ca0 fffff800`a03bd81e : 00000000`00000008 00000000`00000001 ffffe000`b655f880 00000000`00000000 : nt!MmWorkingSetManager+0x4a
    ffffd000`c7cb7cd0 fffff800`a0352794 : ffffe000`b655f880 00000000`00000000 00000000`00000080 00000000`00000000 : nt!KeBalanceSetManager+0x11e
    ffffd000`c7cb7d40 fffff800`a03dd5c6 : ffffd000`c7aaa180 ffffe000`b655f880 ffffd000`c7ab63c0 00000000`00000000 : nt!PspSystemThreadStartup+0x58
    ffffd000`c7cb7da0 00000000`00000000 : ffffd000`c7cb8000 ffffd000`c7cb2000 00000000`00000000 00000000`00000000 : nt!KiStartSystemThread+0x16
    STACK_COMMAND:  kb
    FOLLOWUP_IP: 
    nt!MiAgeWorkingSet+2cb
    fffff800`a02f858b 498b1e          mov     rbx,qword ptr [r14]
    SYMBOL_STACK_INDEX:  3
    SYMBOL_NAME:  nt!MiAgeWorkingSet+2cb
    FOLLOWUP_NAME:  MachineOwner
    MODULE_NAME: nt
    DEBUG_FLR_IMAGE_TIMESTAMP:  53388e13
    IMAGE_VERSION:  6.3.9600.17085
    IMAGE_NAME:  memory_corruption
    BUCKET_ID_FUNC_OFFSET:  2cb
    FAILURE_BUCKET_ID:  AV_nt!MiAgeWorkingSet
    BUCKET_ID:  AV_nt!MiAgeWorkingSet
    ANALYSIS_SOURCE:  KM
    FAILURE_ID_HASH_STRING:  km:av_nt!miageworkingset
    FAILURE_ID_HASH:  {a2dd9c19-c4fc-761b-f40a-b8172b183d05}
    Followup: MachineOwner
    5: kd> .trap 0xffffd000c7cb76d0
    NOTE: The trap frame does not contain all registers.
    Some register values may be zeroed or incorrect.
    rax=0000800000000000 rbx=0000000000000000 rcx=0000ffffffffffff
    rdx=0000000000000008 rsi=0000000000000000 rdi=0000000000000000
    rip=fffff800a02f858b rsp=ffffd000c7cb7860 rbp=ffffd000c7cb7960
     r8=0000000fffffffff  r9=8000000000000000 r10=0000007ffffffff8
    r11=0000098000000000 r12=0000000000000000 r13=0000000000000000
    r14=0000000000000000 r15=0000000000000000
    iopl=0         nv up ei ng nz na po cy
    nt!MiAgeWorkingSet+0x2cb:
    fffff800`a02f858b 498b1e          mov     rbx,qword ptr [r14] ds:00000000`00000000=????????????????
    5: kd> .trap 0xffffd000c7cb76d0
    NOTE: The trap frame does not contain all registers.
    Some register values may be zeroed or incorrect.
    rax=0000800000000000 rbx=0000000000000000 rcx=0000ffffffffffff
    rdx=0000000000000008 rsi=0000000000000000 rdi=0000000000000000
    rip=fffff800a02f858b rsp=ffffd000c7cb7860 rbp=ffffd000c7cb7960
     r8=0000000fffffffff  r9=8000000000000000 r10=0000007ffffffff8
    r11=0000098000000000 r12=0000000000000000 r13=0000000000000000
    r14=0000000000000000 r15=0000000000000000
    iopl=0         nv up ei ng nz na po cy
    nt!MiAgeWorkingSet+0x2cb:
    fffff800`a02f858b 498b1e          mov     rbx,qword ptr [r14] ds:00000000`00000000=????????????????

    These crashes were related to memory corruption (probably caused by a driver). We could use the actual DMP file for analysis
    Please run these tests to verify your memory and find which driver is causing the problem.  
    If you are overclocking (pushing the components beyond their design) you should revert to default at least until the crashing is solved. If you don't
    know what it is you probably are not overclocking.
    Since it is more likely to be a driver please run verifier first.
    1-Driver verifier (for complete directions see our wiki here)
    If verifier does not find the issue we can move on to this.
    2-Memtest. (You can read more about running memtest here)
    If you cannot boot after enabling verifier reboot into safe mode
    In Vista & win 7 (F8)
    In win 8 http://www.howtogeek.com/107511/how-to-boot-into-safe-mode-on-windows-8-the-easy-way/
    Co-Authored by  JMH3143
    Wanikiya and Dyami--Team Zigzag

  • Norton reports high memory usage with firefox and it crashes often

    Norton antivirus 2011 has pop up warnings reporting high memory usage from Firefox. I have been getting theem often and my computer is crashing often after those pop up warnings. Thanks

    Safe mode did not help.
    I have disabled ALL extensions and plug-ins, but the problem with "zig-zag" memory usage still remains (I've not tried to leave browser open for the night yet).
    I think I'll do clean reinstall with completely new empty profile (without sync'ed information) to try this out. If this works, I'll start adding stuff (configuration, sync, features, etc) to see what causes the problem.

  • I upgraded my iBook G4 from 384MBytes to 640Mbytes and upgraded from Tiger to Leopard. After a few weeks the HDD failed. New Leopard install reports: "insufficient memory". I need Tiger install disks so I can install

    I upgraded my iBook G4 from 384MBytes to 640Mbytes and upgraded from Tiger to Leopard.
    After a few weeks the HDD failed. I bought a new disk, installed it and trued to install Leopard, but the  install fails reporting "insufficient memory".
    I assume the installation requires more memory than the OS actually needs to be able to run.
    I need Tiger install CD/DVD so I can install Tiger first and then upgrade to Leopard.

    Call Apple Customer Support 1-800-767-2775, provide the Serial Number and specifications of the Mac, and for a reasonable fee, they will supply a replacement set of system discs (if available).
    The discs will be for the original version of the OS that was pre-installed when the Mac was manufactured.
    You need much more RAM than that.
    Leopard system requirements:
    http://support.apple.com/kb/SP517

Maybe you are looking for

  • Mile stone billing with Down payment clearing

    Hi, Urgent help needed. I need to set up mile stone billing plan at item level with down payment getting automatically offset with Invoice ie, I have 10% down payment (FAZ). And mile stone invoicing of 40% and 60% each. I have raised down payment req

  • LMS 2.6 and ACS 4.2 compatible with Windows 2008 R2 Active Directory?

    Hi, We are planning to upgrade CORP Domain from Windows 2003 Active Directory Schema to Windows 2008 R2 Active Directory Schema. I wanted to know if the following applications which are installed on windows (domain member servers) are compatible with

  • Smartforms supported in SAP CRM 2007?

    I was told by a colleague that smartforms are no longer supported in CRM 2007, only the Adobe Forms integration. However, I have not found any documentation to support this claim. Anyone know, for sure, if smartfroms are still supported in CRM 2007?

  • UOM conversion problem when issuing material against BOM

    Hi All I have a material which is part of a production BOM. The base UOM is EA. The issuing UOM is KG. I have a UOM conversion of 20 KG = 1 EA. In the BOM I need to issue 0.034 KG. When backflushing happens, it issues 1 EA. Why is it not issuing in K

  • Structural authorization only possible in HR,correct?

    It is my strong understanding that strucural authorization is possible only in HR.Can somebody please confirm that it cannot be accomplished for any other module,espicially FI? Thanks.