Converting Iff2Bmp to D

This is a summary of porting the Amiga IFF ILBM converter to the D Programming Language.

This program went through several different languages, each had different strengths and weaknesses:

• Mozilla Rust - Fast and fairly memory safe but horrible file handling when it came to loading structs. There were a lot of other things the compiler really should have been able to figure out too such as this nonsense '#[derive(Default,Copy,Clone)]'.

• FreePascal - No real negatives, just had to make sure bounds checking was turned on. Dynamic arrays simplfied allocations.

• Google Go - Again, no real negatives and I like Go, but the language lacks a lot of minor nicities that the others had (enums, packed structs, immutables).

• C (TCC) - Enabling bounds checking with '-b' in TCC helped, the main task was making sure all allocations were freed before the program exited.

I was happy with the Pascal version but thought porting it to D would be interesting. The D version may be a little quicker (not checked), is fairly memory safe and there were more modern programming techniques/methods that could be applied.

This guide does not repeat the items mentioned in the previous Converting Avi2Cvc from C to D guide.

Simple Stuff

In no particular order:

• Malloc to Dynamic Arrays

  Replaced dynamic memory allocations such as:

  char *frame;
  ...
  frame=(unsigned char *)malloc(framesize);
  

  with

  ubyte[] frame;
  ...
  frame.length=framesize;
  

  The main advantage of doing this is that the compiler/runtime is aware of the allocations. I did not have to track every path in the program to make sure I deallocated the memory before the program exited. Also, thanks to the bounds checking I can be sure I will not be trashing memory and if I do overshoot the bounds, I will be notified!

  In fairness, both Pascal's and Rust's dynamic arrays were not terrible...

• Easy Array Clearing

  A minor thing but, from this:

  // These could have been a memset()
  for(int p=0;p<sizeof(pix);p++){pix[p]=0;}
  for(int p=0;p<sizeof(green);p++){green[p]=0;}
  for(int p=0;p<sizeof(blue);p++){blue[p]=0;}
  

  to

  // Set all values in the arrays to zero
  pix[]=0;
  green[]=0;
  blue[]=0;
  

  Advantages to this include:

  • Less typing = less chance of errors!
  • Easy to read and understand.
  • Lets the compiler figure out the best way to do it.

• Immutable Variables

  These are variables that can be set at runtime but then not changed. They are useful as another defense against accidently changing a value that should not be changed. Good for the compiler too.

  // Find out byte width (including padding) needed
  immutable uint bmp_row_width=byte_width(bmp_info[0].width);
  immutable uint bmp_size=(bmp_row_width*bmp_info[0].height);
  

  Trying to change bmp_size would give an error. Pascal, Go and C do not (to my knowledge) have immutable variables, in Rust everything is immutable by default.

Garbage Collection

I mentioned the GC profiling before but it is worth mentioning again! To get a GC profile log, compile with -profile=gc and when you run the program you get an easy to read profilegc.log file.

Running the profile enabled version gave this:

bytes allocated, allocations, type, function, file:line
          65536	              1	ubyte[] D main iff2bmp.d:437
          65536	              1	ubyte[] D main iff2bmp.d:523
          32768	              1	ubyte[] D main iff2bmp.d:409
            128	              1	ubyte[] D main iff2bmp.d:391
             16	              1	immutable(char)[] D main iff2bmp.d:528
             16	              1	ubyte[] D main iff2bmp.d:420

All good and as expected. The 'immutable(char)' is the output file name, the others allocations are data chunks and buffers.

Last Updated 20/05/2024
Created 15/02/2020