#[repr(align(64))]
struct S(u8);

#[derive(Clone)]
pub struct Blob {
    pub data: BlobData,
    pub meta: Meta,
}

#[repr(align(64))]
pub struct BlobData([u8; BLOB_SIZE]);


impl Clone for BlobData {
    fn clone(&self) -> Self {
        BlobData(self.0)
    }
}
impl Default for BlobData {
    fn default() -> Self {
        BlobData([0u8; BLOB_SIZE])
    }
}

//auto derive doesn't support large arrays
impl Default for Blob {
    fn default() -> Self {
        Blob {
            data: BlobData::default(),
            meta: Meta::default(),
        }
    }
}

pub const BLOB_SIZE: usize = (64 * 1024 - 128); // wikipedia says there should be 20b for ipv4 headers

#[derive(Clone, Default, Debug, PartialEq)]
#[repr(C)]
pub struct Meta {
    pub size: usize,
    pub num_retransmits: u64,
    pub addr: [u16; 8],
    pub port: u16,
    pub v6: bool,
}


fn main() {
    println!("size of S: {}", std::mem::size_of::<S>());
    println!("align of S: {}", std::mem::align_of::<S>());
    println!("align of Blob: {}", std::mem::align_of::<Blob>());
    let mut i = 0;
    let mut blobs = vec![];
    for i in 0..4096 {
      //println!("{:?}", Blob::default().data.0.as_ptr());
      let blob = Blob::default();
      assert_eq!(blob.data.0.as_ptr() as usize & 63, 0);
      blobs.push(blob);
      if i & 31 == 0 {
          println!("{}...", i);
      }

    }
}