#!/bin/bash
#
# Script will generate one flow per thread (-t N)
#  - Same destination IP
#  - Fake source IPs for each flow (fixed based on thread number)
#
# Useful for scale testing on receiver, to see whether silo'ing flows
# works and scales.  For optimal scalability (on receiver) each
# separate-flow should not access shared variables/data. This script
# helps magnify any of these scaling issues by overloading the receiver.
#
global basedir := $[dirname $0]
source $(basedir)/functions.sh
root_check_run_with_sudo @Argv

# Parameter parsing via include
source $(basedir)/parameters.sh
# Set some default params, if they didn't get set
test -z $DEST_IP   && global DEST_IP := '"198.18.0.42'"
test -z $DST_MAC   && global DST_MAC := '"90:e2:ba:ff:ff:ff'"
test -z $CLONE_SKB && global CLONE_SKB := '"0'"
test -z $BURST     && global BURST := '32'


# Base Config
global DELAY := '"0'"  # Zero means max speed
global COUNT := '"0'"  # Zero means indefinitely

# General cleanup everything since last run
pg_ctrl "reset"

# Threads are specified with parameter -t value in $THREADS
for ((thread = 0; thread < $THREADS; thread++)); do
    dev=${DEV}@${thread}

    # Add remove all other devices and add_device $dev to thread
    pg_thread $thread "rem_device_all"
    pg_thread $thread "add_device" $dev

    # Base config
    pg_set $dev "flag QUEUE_MAP_CPU"
    pg_set $dev "count $COUNT"
    pg_set $dev "clone_skb $CLONE_SKB"
    pg_set $dev "pkt_size $PKT_SIZE"
    pg_set $dev "delay $DELAY"
    pg_set $dev "flag NO_TIMESTAMP"

    # Single destination
    pg_set $dev "dst_mac $DST_MAC"
    pg_set $dev "dst $DEST_IP"

    # Setup source IP-addresses based on thread number
    pg_set $dev "src_min 198.18.$((thread+1)).1"
    pg_set $dev "src_max 198.18.$((thread+1)).1"

    # Setup burst, for easy testing -b 0 disable bursting
    # (internally in pktgen default and minimum burst=1)
    if [[ ${BURST} -ne 0 ]]; then
	pg_set $dev "burst $BURST"
    else
	info "$dev: Not using burst"
    fi

done

# Run if user hits control-c
proc print_result {
    # Print results
    for ((thread = 0; thread < $THREADS; thread++)); do
	dev=${DEV}@${thread}
	echo "Device: $dev"
	cat /proc/net/pktgen/$dev | grep -A2 "Result:"
    done
}
# trap keyboard interrupt (Ctrl-C)
trap true SIGINT

echo "Running... ctrl^C to stop" > !2
pg_ctrl "start"

print_result
(CommandList
  children: [
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:basedir)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: (CommandList children:[(C {(dirname)} {($ VSub_Number "$0")})])
                left_token: <Left_Backtick "`">
                spids: [34 38]
              )
            }
          spids: [33]
        )
      ]
      spids: [33]
    )
    (C {(source)} {(${ VSub_Name basedir) (/functions.sh)})
    (C {(root_check_run_with_sudo)} {(DQ ($ VSub_At "$@"))})
    (C {(source)} {(${ VSub_Name basedir) (/parameters.sh)})
    (AndOr
      children: [
        (C {(Lit_Other "[")} {(-z)} {(DQ ($ VSub_Name "$DEST_IP"))} {(Lit_Other "]")})
        (Assignment
          keyword: Assign_None
          pairs: [
            (assign_pair
              lhs: (LhsName name:DEST_IP)
              op: Equal
              rhs: {(DQ (198.18.0.42))}
              spids: [79]
            )
          ]
          spids: [79]
        )
      ]
      op_id: Op_DAmp
    )
    (AndOr
      children: [
        (C {(Lit_Other "[")} {(-z)} {(DQ ($ VSub_Name "$DST_MAC"))} {(Lit_Other "]")})
        (Assignment
          keyword: Assign_None
          pairs: [
            (assign_pair
              lhs: (LhsName name:DST_MAC)
              op: Equal
              rhs: {(DQ ("90:e2:ba:ff:ff:ff"))}
              spids: [96]
            )
          ]
          spids: [96]
        )
      ]
      op_id: Op_DAmp
    )
    (AndOr
      children: [
        (C {(Lit_Other "[")} {(-z)} {(DQ ($ VSub_Name "$CLONE_SKB"))} {(Lit_Other "]")})
        (Assignment
          keyword: Assign_None
          pairs: [(assign_pair lhs:(LhsName name:CLONE_SKB) op:Equal rhs:{(DQ (0))} spids:[113])]
          spids: [113]
        )
      ]
      op_id: Op_DAmp
    )
    (AndOr
      children: [
        (C {(Lit_Other "[")} {(-z)} {(DQ ($ VSub_Name "$BURST"))} {(Lit_Other "]")})
        (Assignment
          keyword: Assign_None
          pairs: [(assign_pair lhs:(LhsName name:BURST) op:Equal rhs:{(32)} spids:[130])]
          spids: [130]
        )
      ]
      op_id: Op_DAmp
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:DELAY) op:Equal rhs:{(DQ (0))} spids:[138])]
      spids: [138]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:COUNT) op:Equal rhs:{(DQ (0))} spids:[146])]
      spids: [146]
    )
    (C {(pg_ctrl)} {(DQ (reset))})
    (ForExpr
      init: 
        (BinaryAssign
          op_id: Arith_Equal
          left: (LhsName name:thread)
          right: (ArithWord w:{(Lit_Digits 0)})
        )
      cond: 
        (ArithBinary
          op_id: Arith_Less
          left: (ArithVarRef name:thread)
          right: (ArithWord w:{($ VSub_Name "$THREADS")})
        )
      update: (UnaryAssign op_id:Node_PostDPlus child:(LhsName name:thread))
      body: 
        (DoGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:dev)
                  op: Equal
                  rhs: {(${ VSub_Name DEV) (Lit_Other "@") (${ VSub_Name thread)}
                  spids: [194]
                )
              ]
              spids: [194]
            )
            (C {(pg_thread)} {($ VSub_Name "$thread")} {(DQ (rem_device_all))})
            (C {(pg_thread)} {($ VSub_Name "$thread")} {(DQ (add_device))} {($ VSub_Name "$dev")})
            (C {(pg_set)} {($ VSub_Name "$dev")} {(DQ ("flag QUEUE_MAP_CPU"))})
            (C {(pg_set)} {($ VSub_Name "$dev")} {(DQ ("count ") ($ VSub_Name "$COUNT"))})
            (C {(pg_set)} {($ VSub_Name "$dev")} {(DQ ("clone_skb ") ($ VSub_Name "$CLONE_SKB"))})
            (C {(pg_set)} {($ VSub_Name "$dev")} {(DQ ("pkt_size ") ($ VSub_Name "$PKT_SIZE"))})
            (C {(pg_set)} {($ VSub_Name "$dev")} {(DQ ("delay ") ($ VSub_Name "$DELAY"))})
            (C {(pg_set)} {($ VSub_Name "$dev")} {(DQ ("flag NO_TIMESTAMP"))})
            (C {(pg_set)} {($ VSub_Name "$dev")} {(DQ ("dst_mac ") ($ VSub_Name "$DST_MAC"))})
            (C {(pg_set)} {($ VSub_Name "$dev")} {(DQ ("dst ") ($ VSub_Name "$DEST_IP"))})
            (C {(pg_set)} {($ VSub_Name "$dev")} 
              {
                (DQ ("src_min 198.18.") 
                  (ArithSubPart
                    anode: 
                      (ArithBinary
                        op_id: Arith_Plus
                        left: (ArithVarRef name:thread)
                        right: (ArithWord w:{(Lit_Digits 1)})
                      )
                    spids: [328 333]
                  ) (.1)
                )
              }
            )
            (C {(pg_set)} {($ VSub_Name "$dev")} 
              {
                (DQ ("src_max 198.18.") 
                  (ArithSubPart
                    anode: 
                      (ArithBinary
                        op_id: Arith_Plus
                        left: (ArithVarRef name:thread)
                        right: (ArithWord w:{(Lit_Digits 1)})
                      )
                    spids: [344 349]
                  ) (.1)
                )
              }
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (BoolBinary
                              op_id: BoolBinary_ne
                              left: {(${ VSub_Name BURST)}
                              right: {(0)}
                            )
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (C {(pg_set)} {($ VSub_Name "$dev")} {(DQ ("burst ") ($ VSub_Name "$BURST"))})
                  ]
                  spids: [-1 378]
                )
              ]
              else_action: [(C {(info)} {(DQ ($ VSub_Name "$dev") (": Not using burst"))})]
              spids: [391 402]
            )
          ]
          spids: [191 405]
        )
    )
    (FuncDef
      name: print_result
      body: 
        (BraceGroup
          children: [
            (ForExpr
              init: 
                (BinaryAssign
                  op_id: Arith_Equal
                  left: (LhsName name:thread)
                  right: (ArithWord w:{(Lit_Digits 0)})
                )
              cond: 
                (ArithBinary
                  op_id: Arith_Less
                  left: (ArithVarRef name:thread)
                  right: (ArithWord w:{($ VSub_Name "$THREADS")})
                )
              update: (UnaryAssign op_id:Node_PostDPlus child:(LhsName name:thread))
              body: 
                (DoGroup
                  children: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:dev)
                          op: Equal
                          rhs: {(${ VSub_Name DEV) (Lit_Other "@") (${ VSub_Name thread)}
                          spids: [450]
                        )
                      ]
                      spids: [450]
                    )
                    (C {(echo)} {(DQ ("Device: ") ($ VSub_Name "$dev"))})
                    (Pipeline
                      children: [
                        (C {(cat)} {(/proc/net/pktgen/) ($ VSub_Name "$dev")})
                        (C {(grep)} {(-A2)} {(DQ ("Result:"))})
                      ]
                      negated: False
                    )
                  ]
                  spids: [447 484]
                )
            )
          ]
          spids: [417]
        )
      spids: [411 416]
    )
    (C {(trap)} {(true)} {(SIGINT)})
    (SimpleCommand
      words: [{(echo)} {(DQ ("Running... ctrl^C to stop"))}]
      redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(2)} spids:[504])]
    )
    (C {(pg_ctrl)} {(DQ (start))})
    (C {(print_result)})
  ]
)