Skip to main content
SimilarExport ZIP
100%

Stress testing Azure Analysis Services. Run as AzureASLoadTest 5 (#number of parallel executions)

✓ Published0🌍 Public
HHugoberry
Last edited Aug 21, 2017
Created on Aug 21, 2017

This example demonstrates a stress test for Azure Analysis Services, showing how the system handles multiple simultaneous queries against a tabular model. The code defines a PowerShell workflow that launches a specified number of parallel executions, each sending a complex DAX query that performs a crossjoin of two date tables to generate a large result set. The script uses the `Invoke-ASCmd` cmdlet to connect to the Azure Analysis Services instance and authenticate with credentials, while the `foreach -parallel` construct distributes the workload across concurrent connections. The visualization highlights the performance impact of increasing connection counts on the service's responsiveness and throughput.

AI-generated description

Similar vizzes

Loading thumbnail…

Parallel processing of Tabular SSAS 2016 PowerShell vs JSON versions

This example compares two approaches to processing tabular data in SQL Server Analysis Services (SSAS) 2016: a PowerShell script and a JSON definition file, both targeting the same parallel refresh operation. The visualization contrasts the imperative PowerShell API—using `RequestRefresh` and `SaveChanges` with `MaxParallelism` set to 5—against the declarative JSON `sequence` object that specifies the same refresh and calculate steps. It highlights how the two syntaxes map to identical table refresh actions on "Internet Sales" and "Reseller Sales," followed by a model-wide calculate pass, while the parallel execution logic differs in representation. The data source is the AdventureWorks database, and the example uses Microsoft.AnalysisServices.Tabular and the JSON sequence format.

HHugoberry
67% match
Loading thumbnail…

Counting the number of cores in Azure Analysis Services

This example visualizes how many processor cores are available in an Azure Analysis Services instance by querying Windows performance counters. It shows the processor frequency for each individual core, from 0 to 31, revealing the total core count and their activity. The visualization uses a DAX query with the `SYSTEMRESTRICTSCHEMA` function to retrieve data from `DISCOVER_PERFORMANCE_COUNTERS`, explicitly listing each `Processor Information` counter. The rendering relies on the data returned by this query, presenting the per-core frequencies as a direct measure of the allocated compute resources.

HHugoberry
59% match
Loading thumbnail…

Parallel execution with Azure Functions PART1

This example demonstrates a serverless approach to computing a Mandelbrot set in parallel using Azure Functions. It shows how an HTTP-triggered function decomposes a rendering task into discrete horizontal strips, each queued as a separate work item via `IAsyncCollector<MandelbrotBatch>`. The code uses `HttpRequestMessage` to receive a `MandelbrotSetRequest`, generates evenly spaced y-coordinates with `Generate.LinearSpaced`, and enqueues each batch with a unique output folder GUID. The function returns the folder ID to the caller, while the queue orchestrates distributed processing of each row, leveraging Azure Queues for scalable parallelism.

HHugoberry
56% match
Loading thumbnail…

Parallel execution with Azure Function PART2

This example shows a serverless Azure Function that computes a single row of a Mandelbrot set and writes it to blob storage, demonstrating parallel execution by partitioning the workload across multiple function invocations. The code uses an `IBinder` to dynamically create a blob output for each batch, with `Generate.LinearSpaced` generating the x-coordinates and LINQ’s `Select` mapping each x-value to a `MandelbrotPoint` at a fixed y-coordinate. Each function run processes one batch and serializes the resulting row as JSON via `JsonConvert.SerializeObject`, saving it as a GUID-named blob in the specified folder. The visualization implicitly relies on the aggregation of these row blobs, though the rendering itself is not shown here.

HHugoberry
55% match
Loading thumbnail…

Gist ed4042b20f9bcfc3ee801039049ad47f

This example shows the port number on which the SQL Server Analysis Services process (msmdsrv.exe) is listening by extracting it from live TCP connection data. It first identifies the process ID using the Windows `tasklist` command, then filters `netstat -ano` output for established connections matching that PID, and finally parses the local address to isolate the port. The visualization is implemented in Power Query’s M language, which invokes an embedded R script via the `R.Execute` function to perform the system calls and string processing. The result is a single value displayed as a table cell, demonstrating a system-monitoring query rendered through the Power BI data pipeline.

HHugoberry
53% match
Loading thumbnail…

Exposing #shared construct in Azure Analysis Services (change DatabaseID accordingly)

This example shows how to expose the contents of Power Query's `#shared` intrinsic constant inside an Azure Analysis Services tabular model, turning the built-in M function and value registry into a queryable table. The workflow uses three XMLA/TMSL scripts: first, an XMLA `Create` command injects a shared expression named `SharedExpression` that returns `#shared`; second, a TMSL `create` operation defines a table with `Name` and `Value` string columns, pulling data through an M partition expression that references the injected shared expression; finally, a TMSL `refresh` command processes the new table. The result is then viewed with a DAX `evaluate` statement against the `SharedExpressionTable`, demonstrating a round-trip from M metadata to a usable relational structure. The code relies on the XMLA protocol, TMSL JSON APIs, and the M expression engine, with no external visualization library involved.

HHugoberry
53% match
Loading thumbnail…

Gist f90e0dcc12099646652c5dcbc8400a24

This example visualizes the live query log of a Power BI tabular model by monitoring the Analysis Services workspace’s in-memory engine. It shows the most recent command and its start time, appending each new entry to a running history. The code uses the Power Query M language, calling `AnalysisServices.Database` to query the `$SYSTEM.DISCOVER_SESSIONS` DMV and `Folder.Files` to locate the `msmdsrv.port.txt` file that defines the dynamic port. The rendered output is a table combining previous and new log records via `Table.Combine`, with no external charting library involved.

HHugoberry
52% match
Loading thumbnail…

Gist 44e95c5ae2e212c1b41485ea7e31e0c4

This example shows a Power Query function that connects to an embedded Power BI Desktop tabular model and retrieves session information from the `$SYSTEM.DISCOVER_SESSIONS` dynamic management view. The function first locates the most recently accessed user profile folder, reads the `msmdsrv.port.txt` file to obtain the local port number, then uses that port to list available databases via the `AnalysisServices.Databases` API. It selects the first database and executes the provided DAX query using `AnalysisServices.Database`. The code demonstrates dynamic file system traversal, port discovery, and parameterized Analysis Services queries within the Power Query M language.

HHugoberry
52% match