Changeset aa1d13c


Ignore:
Timestamp:
Dec 17, 2020, 3:50:18 PM (10 months ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
arm-eh, jacob/cs343-translation, master, new-ast-unique-expr
Children:
c5a98f3
Parents:
94d9351
Message:

Refactored code to track data and goroutine migrations

File:
1 edited

Legend:

Unmodified
Added
Removed
  • benchmark/readyQ/locality.go

    r94d9351 raa1d13c  
    77        "math/rand"
    88        "os"
     9        "syscall"
    910        "sync/atomic"
    1011        "time"
     
    1516)
    1617
    17 type GoCtx struct {
     18// ==================================================
     19type MyData struct {
     20        ttid int
     21        id int
     22        data [] uint64
     23}
     24
     25func NewData(id int, size uint64) (*MyData) {
     26        var data [] uint64
     27        data = make([]uint64, size)
     28        for i := uint64(0); i < size; i++ {
     29                data[i] = 0
     30        }
     31        return &MyData{syscall.Gettid(), id, data}
     32}
     33
     34func (this * MyData) moved( ttid int ) (uint64) {
     35        if this.ttid == ttid {
     36                return 0
     37        }
     38        this.ttid = ttid
     39        return 1
     40}
     41
     42func (this * MyData) access( idx uint64 ) {
     43        this.data[idx % uint64(len(this.data))] += 1
     44}
     45
     46// ==================================================
     47type MyCtx struct {
    1848        s * semaphore.Weighted
    1949        d unsafe.Pointer
    2050        c context.Context
     51        ttid int
    2152        id int
    2253}
    2354
     55func NewCtx( sem * semaphore.Weighted, data * MyData, id int ) (MyCtx) {
     56        return MyCtx{sem, unsafe.Pointer(data), context.Background(), syscall.Gettid(), id}
     57}
     58
     59func (this * MyCtx) moved( ttid int ) (uint64) {
     60        if this.ttid == ttid {
     61                return 0
     62        }
     63        this.ttid = ttid
     64        return 1
     65}
     66
     67// ==================================================
    2468type Spot struct {
    2569        ptr uintptr
     
    3175// Next threads unblocks current one and blocks in its place
    3276// if share == true, exchange data in the process
    33 func (this * Spot) put( ctx * GoCtx, data * [] uint64, share bool) (* [] uint64, bool) {
     77func (this * Spot) put( ctx * MyCtx, data * MyData, share bool) (* MyData, bool) {
    3478        new := uintptr(unsafe.Pointer(ctx))
    3579        // old_d := ctx.d
     
    4690
    4791        if raw != uintptr(0) {
    48                 var val *GoCtx
    49                 val = (*GoCtx)(unsafe.Pointer(raw))
     92                var val *MyCtx
     93                val = (*MyCtx)(unsafe.Pointer(raw))
    5094                if share {
    5195                        // fmt.Printf("[%d] - %d update %d: %p -> %p\n", this.id, ctx.id, val.id, val.d, data)
     
    59103        // fmt.Printf("[%d] - %d enter\n", this.id, ctx.id)
    60104        ctx.s.Acquire(ctx.c, 1)
    61         ret := (* [] uint64)(atomic.LoadPointer(&ctx.d))
     105        ret := (* MyData)(atomic.LoadPointer(&ctx.d))
    62106        // fmt.Printf("[%d] - %d leave: %p -> %p\n", this.id, ctx.id, ret, old_d)
    63107
     
    66110
    67111func (this * Spot) release() {
    68         val := (*GoCtx)(unsafe.Pointer(atomic.SwapUintptr(&this.ptr, uintptr(1))))
     112        val := (*MyCtx)(unsafe.Pointer(atomic.SwapUintptr(&this.ptr, uintptr(1))))
    69113        if val == nil {
    70114                return
     
    74118}
    75119
     120// ==================================================
     121type Result struct {
     122        count uint64
     123        gmigs uint64
     124        dmigs uint64
     125}
     126
     127func NewResult() (Result) {
     128        return Result{0, 0, 0}
     129}
     130
     131// ==================================================
    76132func __xorshift64( state * uint64 ) (uint64) {
    77133        x := *state
     
    83139}
    84140
    85 func work(data * [] uint64, size uint64, cnt uint64, state * uint64) {
     141func work(data * MyData, cnt uint64, state * uint64) {
    86142        for i := uint64(0); i < cnt; i++ {
    87                 (*data)[__xorshift64(state) % size] += 1
    88         }
    89 }
    90 
    91 func local(result chan uint64, start chan struct{}, size uint64, cnt uint64, channels [] Spot, share bool, id int) {
     143                data.access(__xorshift64(state))
     144        }
     145}
     146
     147func local(result chan Result, start chan struct{}, size uint64, cnt uint64, channels [] Spot, share bool, id int) {
    92148        state := rand.Uint64()
    93         var my_data [] uint64
    94         my_data = make([]uint64, size)
    95         for i := uint64(0); i < size; i++ {
    96                 my_data[i] = 0
    97         }
    98         data := &my_data
    99 
     149
     150        data := NewData(id, size)
    100151        sem := semaphore.NewWeighted(1)
    101152        sem.Acquire(context.Background(), 1)
    102         ctx := GoCtx{sem, unsafe.Pointer(data), context.Background(), id}
    103 
    104         count := uint64(0)
     153        ctx := NewCtx(sem, data, id)
     154
     155        r := NewResult()
    105156        <- start
    106157        for true {
    107                 work(data, size, cnt, &state)
     158                work(data, cnt, &state)
    108159
    109160                i := __xorshift64(&state) % uint64(len(channels))
    110161                var closed bool
    111162                data, closed = channels[i].put(&ctx, data, share)
    112                 count += 1
    113163
    114164                if closed { break }
    115165                if  clock_mode && atomic.LoadInt32(&stop) == 1 { break }
    116                 if !clock_mode && count >= stop_count { break }
    117                 if uint64(len(*data)) != size {
     166                if !clock_mode && r.count >= stop_count { break }
     167                if uint64(len(data.data)) != size {
    118168                        panic("Data has weird size")
    119169                }
     170
     171                ttid := syscall.Gettid()
     172                r.count += 1
     173                r.gmigs += ctx .moved(ttid)
     174                r.dmigs += data.moved(ttid)
    120175        }
    121176
    122177        atomic.AddInt64(&threads_left, -1);
    123         result <- count
     178        result <- r
    124179}
    125180
     
    142197        barrierStart := make(chan struct{})
    143198        threads_left = int64(nprocs)
    144         result  := make(chan uint64)
     199        result  := make(chan Result)
    145200        channels := make([]Spot, nthreads - nprocs)
    146201        for i := range channels {
     
    169224        }
    170225
    171         global_counter := uint64(0)
     226        global_result := NewResult()
    172227        for i := 0; i < nthreads; i++ {
    173228                r := <- result
    174                 global_counter += r
    175                 fmt.Printf("%d\n", r)
     229                global_result.count += r.count
     230                global_result.gmigs += r.gmigs
     231                global_result.dmigs += r.dmigs
    176232        }
    177233
     
    181237        p.Printf("Number of threads      : %d\n", nthreads);
    182238        p.Printf("Work size (64bit words): %d\n", size);
    183         p.Printf("Total Operations(ops)  : %15d\n", global_counter)
    184         p.Printf("Ops per second         : %18.2f\n", float64(global_counter) / delta.Seconds())
    185         p.Printf("ns per ops             : %18.2f\n", float64(delta.Nanoseconds()) / float64(global_counter))
    186         p.Printf("Ops per threads        : %15d\n", global_counter / uint64(nthreads))
    187         p.Printf("Ops per procs          : %15d\n", global_counter / uint64(nprocs))
    188         p.Printf("Ops/sec/procs          : %18.2f\n", (float64(global_counter) / float64(nprocs)) / delta.Seconds())
    189         p.Printf("ns per ops/procs       : %18.2f\n", float64(delta.Nanoseconds()) / (float64(global_counter) / float64(nprocs)))
    190 }
     239        p.Printf("Total Operations(ops)  : %15d\n", global_result.count)
     240        p.Printf("Total G Migrations     : %15d\n", global_result.gmigs)
     241        p.Printf("Total D Migrations     : %15d\n", global_result.dmigs)
     242        p.Printf("Ops per second         : %18.2f\n", float64(global_result.count) / delta.Seconds())
     243        p.Printf("ns per ops             : %18.2f\n", float64(delta.Nanoseconds()) / float64(global_result.count))
     244        p.Printf("Ops per threads        : %15d\n", global_result.count / uint64(nthreads))
     245        p.Printf("Ops per procs          : %15d\n", global_result.count / uint64(nprocs))
     246        p.Printf("Ops/sec/procs          : %18.2f\n", (float64(global_result.count) / float64(nprocs)) / delta.Seconds())
     247        p.Printf("ns per ops/procs       : %18.2f\n", float64(delta.Nanoseconds()) / (float64(global_result.count) / float64(nprocs)))
     248}
Note: See TracChangeset for help on using the changeset viewer.