d2b | Reusable d3-based chart library | Data Visualization library

After the definition of bc1 change to

Of course this will fail in the first step. You initialize everything to zero, and then in the derivatives function, you divide by T, which is zero from the initialization.

• Find a more realistic initialization of T, for instance

I've done some experiments using LIKWID, which is similar to PAPI, on Haswell. I found out that the calls to the functions that initialize and read the performance counters can cause more than 600 replacements in the L1 cache. Since the L1 cache has only 512 lines, this means that these functions may evict many of the lines that you would otherwise expect to be in the L1. By looking at the relatively large source code of PAPI_start_counters and _internal_hl_read_cnts, it seems to me that these functions may evict many lines from the L1, so the array elements don't survive in the L1 across these calls. I've verified this by using loads instead of stores and counting hits and misses using MEM_LOAD_RETIRED.*. I think the solution would be to use the RDPMC instruction. I have not used this instruction directly before. The code snippets here look useful.

Alternatively, you can put two copies of the loop after PAPI_start_counters/PAPI_read_counters and then subtract from the results the counts for one copy of the loop. This method works well.

By the way, the L1D.REPLACEMENT counter seems to be fairly accurate on Haswell when the number of cache lines accessed is about larger than 10. Perhaps the count would be exact by using RDPMC.

From your previous question, it seems that you're on Skylake. According to the PAPI event mapping, PAPI_L1_DCM and PAPI_L2_TCM are mapped to L1D.REPLACEMENT and LONGEST_LAT_CACHE.REFERENCE performance monitoring events on Intel processors. These are defined in the Intel manual as follows:

L1D.REPLACEMENT: Counts L1D data line replacements including opportunistic replacements, and replacements that require stall-for-replace or block-for-replace.

LONGEST_LAT_CACHE.REFERENCE: This event counts core-originated cacheable demand requests that refer to the last level cache (LLC). Demand requests include loads, RFOs, and hardware prefetches from L1D, and instruction fetches from IFU.

Without getting into the details of when these events exactly occur, there are three important points here that are relevant to your question:

• Both events are counted at the cache-line granularity, not x86 instruction or load uop granularities.
• These events may occur due to the L1D hardware prefetchers. This can impact miss2.
• There is no way to count L1D hits at the cache line granularity for a specific physical or logical core using these events (or any other set of events on SnB-based micoarchitectures).

On Skylake, there are other native events that you can use to count L1D misses and hits per load instruction. You can use MEM_LOAD_RETIRED.L1_HIT to count the number of retired load instructions that hit in the L1D. You can use MEM_INST_RETIRED.ALL_LOADS-MEM_LOAD_RETIRED.L1_HIT to count the number of retired load instructions that miss in the L1D. There doesn't seem to be PAPI events for them. According to the documentation, you can pass native event codes to PAPIF_start_counters.

Another issue is that it's not clear to me whether PAPIF_start_counters by default will count only user events of both kernel and user events. It seems that you can use PAPI_create_eventset to control the counting domain.

The calls to PAPI APIs can also impact the event counts. You can try to measure this using an empty block as follows:

You probably have a invisible space after the \ in the end of one of the lines above. I suggest that instead of using continuation characters, you just close the string and open it again in next line, it is less fragile and works better:

So for anyone else who will one day have this same issue. If you are using vue.d2b to create your sunburst graphs, the way to sort the graph is with the following code.

Your example code throws an error for me here that says d3_rgbString is undefined, its defined in the source code and intended to be use only internally for certain methods of d3. But, you are over-complicating, range is an array (of colors in this case). You have an array - but not of colors, of numbers, d3_rgbString is intended to convert those numbers to strings that can be used to color elements (expanding the code here):

{N..M}, for integer literals N and M, generates the series of integers from N to M, inclusively, separated by spaces. This is called a "brace expansion", and is a bashism. As you can see, all brace expansions are done before adding spaces between them.

variable=({some expansion}) puts each of the expanded items in an array, and ${variable[index number]} extracts the value at that index. So your code effectively returns the number seven in binary string form.

I've integrated the comments from danieltakeshi in this solution. It isn't the most efficient, but it is easy to follow and shows two methods of achieving the same end. Comments are included in the code. In overarching terms, I've created a number of variables: two dedicated to each sheet, one to the search criteria, two to determine the extent of data in the L ranges, two to test cells in each range, a varible to cycle through rows and a variable to change search criteria with the Find function.

I've set the limits on the useful ranges, tested the matching pieces of info to put the D2C #s in Sheet 2 and then back into Sheet 1. I have some concern that your logic is duplicating itself without needing to, if you're extracting the same information twice...i.e., consider rethinking how this program is organized.

The code itself: